From f23594e11488555dac241958e49b28abf2ee5e0b Mon Sep 17 00:00:00 2001 From: JW Wang Date: Sun, 8 Oct 2017 17:07:55 +0200 Subject: [PATCH 01/15] Bug 1402584. P1 - Backed out changeset 442e8020e2ac. r=gerald MozReview-Commit-ID: JqZJDTMyKGm --- dom/html/HTMLMediaElement.cpp | 21 --------------------- dom/media/MediaDecoder.h | 3 --- 2 files changed, 24 deletions(-) diff --git a/dom/html/HTMLMediaElement.cpp b/dom/html/HTMLMediaElement.cpp index b645955ec6c5..bd3d25196ca7 100644 --- a/dom/html/HTMLMediaElement.cpp +++ b/dom/html/HTMLMediaElement.cpp @@ -2845,17 +2845,6 @@ HTMLMediaElement::Seek(double aTime, mPlayingBeforeSeek = IsPotentiallyPlaying(); -#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED - if (!mDecoder->IsMetadataLoaded()) { - // This is for debugging bug 1402584. - // We should reach here only after metadata loaded by the decoder. - MOZ_CRASH_UNSAFE_PRINTF( - "Metadata not loaded! readyState=%d networkState=%d", - static_cast(mReadyState.Ref()), - static_cast(mNetworkState)); - } -#endif - // The media backend is responsible for dispatching the timeupdate // event if it changes the playback position as a result of the seek. LOG(LogLevel::Debug, ("%p SetCurrentTime(%f) starting seek", this, aTime)); @@ -6053,16 +6042,6 @@ void HTMLMediaElement::ChangeReadyState(nsMediaReadyState aState) mReadyState >= nsIDOMHTMLMediaElement::HAVE_ENOUGH_DATA) { DispatchAsyncEvent(NS_LITERAL_STRING("canplaythrough")); } - -#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED - if (mReadyState >= nsIDOMHTMLMediaElement::HAVE_METADATA && mDecoder && - !mDecoder->IsMetadataLoaded()) { - MOZ_CRASH_UNSAFE_PRINTF( - "Metadata not loaded! readyState=%d networkState=%d", - static_cast(mReadyState.Ref()), - static_cast(mNetworkState)); - } -#endif } static const char* const gNetworkStateToString[] = { diff --git a/dom/media/MediaDecoder.h b/dom/media/MediaDecoder.h index 74b103e5a289..6d0d5e3787f5 100644 --- a/dom/media/MediaDecoder.h +++ b/dom/media/MediaDecoder.h @@ -240,9 +240,6 @@ public: // are buffered and playable. virtual media::TimeIntervals GetBuffered(); - // For debugging bug 1402584. - bool IsMetadataLoaded() const { return !!mInfo; } - // Returns the size, in bytes, of the heap memory used by the currently // queued decoded video and audio data. size_t SizeOfVideoQueue(); From 49c2485657ff683cc5b9b180b5cc4b7c282a9d12 Mon Sep 17 00:00:00 2001 From: JW Wang Date: Sun, 8 Oct 2017 17:08:00 +0200 Subject: [PATCH 02/15] Bug 1402584. P2 - reset readyState to HAVE_NOTHING before loading next source child. See comment 18 for the root cause. r=gerald on a CLOSED TREE Also assert readyState is HAVE_NOTHING before creating a new decoder. MozReview-Commit-ID: B0QACf96AA3 --HG-- extra : amend_source : ef4b41db04ee10f7eaae8f388d984ed0fd0863b5 --- dom/html/HTMLMediaElement.cpp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/dom/html/HTMLMediaElement.cpp b/dom/html/HTMLMediaElement.cpp index bd3d25196ca7..644471cafd88 100644 --- a/dom/html/HTMLMediaElement.cpp +++ b/dom/html/HTMLMediaElement.cpp @@ -1913,6 +1913,12 @@ void HTMLMediaElement::QueueLoadFromSourceTask() return; } + if (mDecoder) { + // Reset readyState to HAVE_NOTHING since we're going to load a new decoder. + ShutdownDecoder(); + ChangeReadyState(nsIDOMHTMLMediaElement::HAVE_NOTHING); + } + ChangeDelayLoadStatus(true); ChangeNetworkState(nsIDOMHTMLMediaElement::NETWORK_LOADING); RefPtr r = NewRunnableMethod("HTMLMediaElement::LoadFromSourceChildren", @@ -4856,6 +4862,7 @@ HTMLMediaElement::InitializeDecoderAsClone(ChannelMediaDecoder* aOriginal) { NS_ASSERTION(mLoadingSrc, "mLoadingSrc must already be set"); NS_ASSERTION(mDecoder == nullptr, "Shouldn't have a decoder"); + MOZ_DIAGNOSTIC_ASSERT(mReadyState == nsIDOMHTMLMediaElement::HAVE_NOTHING); MediaDecoderInit decoderInit(this, mMuted ? 0.0 : mVolume, @@ -4909,6 +4916,7 @@ nsresult HTMLMediaElement::InitializeDecoderForChannel(nsIChannel* aChannel, nsIStreamListener** aListener) { NS_ASSERTION(mLoadingSrc, "mLoadingSrc must already be set"); + MOZ_DIAGNOSTIC_ASSERT(mReadyState == nsIDOMHTMLMediaElement::HAVE_NOTHING); DecoderDoctorDiagnostics diagnostics; From c0ee13bc8bf41a4cc60b871096a88438e9fc9c9d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= Date: Sun, 8 Oct 2017 06:04:28 -0500 Subject: [PATCH 03/15] servo: Merge #18781 - style: Add a simple custom properties benchmark (from emilio:custom-props-bench); r=heycam This is going to help the work in bug 1405411. Source-Repo: https://github.com/servo/servo Source-Revision: 47efcd5e52afd62dcd84ba350948039f67613e20 --HG-- extra : subtree_source : https%3A//hg.mozilla.org/projects/converted-servo-linear extra : subtree_revision : 3194de3a0a9c123f0a507e4d2f6e01abd89b3d69 --- servo/components/style/custom_properties.rs | 11 +++-- .../style/properties/properties.mako.rs | 2 +- servo/components/style/thread_state.rs | 4 +- .../style/values/specified/image.rs | 12 ++--- servo/tests/unit/style/custom_properties.rs | 49 +++++++++++++++++++ servo/tests/unit/style/lib.rs | 1 + 6 files changed, 66 insertions(+), 13 deletions(-) create mode 100644 servo/tests/unit/style/custom_properties.rs diff --git a/servo/components/style/custom_properties.rs b/servo/components/style/custom_properties.rs index 9da84c3cc16f..7fd74f83c1be 100644 --- a/servo/components/style/custom_properties.rs +++ b/servo/components/style/custom_properties.rs @@ -8,7 +8,6 @@ use Atom; use cssparser::{Delimiter, Parser, ParserInput, SourcePosition, Token, TokenSerializationType}; -use parser::ParserContext; use precomputed_hash::PrecomputedHash; use properties::{CSSWideKeyword, DeclaredValue}; use selector_map::{PrecomputedHashSet, PrecomputedDiagnosticHashMap}; @@ -246,15 +245,17 @@ impl ComputedValue { impl SpecifiedValue { /// Parse a custom property SpecifiedValue. pub fn parse<'i, 't>( - _context: &ParserContext, input: &mut Parser<'i, 't>, ) -> Result, ParseError<'i>> { let mut references = PrecomputedHashSet::default(); - let (first, css, last) = parse_self_contained_declaration_value(input, Some(&mut references))?; + + let (first_token_type, css, last_token_type) = + parse_self_contained_declaration_value(input, Some(&mut references))?; + Ok(Box::new(SpecifiedValue { css: css.into_owned(), - first_token_type: first, - last_token_type: last, + first_token_type, + last_token_type, references })) } diff --git a/servo/components/style/properties/properties.mako.rs b/servo/components/style/properties/properties.mako.rs index 7de94c689d98..031bd1e580b6 100644 --- a/servo/components/style/properties/properties.mako.rs +++ b/servo/components/style/properties/properties.mako.rs @@ -1635,7 +1635,7 @@ impl PropertyDeclaration { // This probably affects some test results. let value = match input.try(|i| CSSWideKeyword::parse(i)) { Ok(keyword) => DeclaredValueOwned::CSSWideKeyword(keyword), - Err(()) => match ::custom_properties::SpecifiedValue::parse(context, input) { + Err(()) => match ::custom_properties::SpecifiedValue::parse(input) { Ok(value) => DeclaredValueOwned::Value(value), Err(e) => return Err(PropertyDeclarationParseError::InvalidValue(name.to_string().into(), ValueParseError::from_parse_error(e))), diff --git a/servo/components/style/thread_state.rs b/servo/components/style/thread_state.rs index 894cdb4a813b..d06f47aabe4d 100644 --- a/servo/components/style/thread_state.rs +++ b/servo/components/style/thread_state.rs @@ -53,7 +53,9 @@ thread_local!(static STATE: RefCell> = RefCell::new(None)); pub fn initialize(x: ThreadState) { STATE.with(|ref k| { if let Some(ref s) = *k.borrow() { - panic!("Thread state already initialized as {:?}", s); + if x != *s { + panic!("Thread state already initialized as {:?}", s); + } } *k.borrow_mut() = Some(x); }); diff --git a/servo/components/style/values/specified/image.rs b/servo/components/style/values/specified/image.rs index 406f4beee3b7..feb4e044c932 100644 --- a/servo/components/style/values/specified/image.rs +++ b/servo/components/style/values/specified/image.rs @@ -908,18 +908,18 @@ impl Parse for ColorStop { } impl Parse for PaintWorklet { - fn parse<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>) -> Result> { + fn parse<'i, 't>( + _context: &ParserContext, + input: &mut Parser<'i, 't>, + ) -> Result> { input.expect_function_matching("paint")?; input.parse_nested_block(|input| { let name = Atom::from(&**input.expect_ident()?); let arguments = input.try(|input| { input.expect_comma()?; - input.parse_comma_separated(|input| Ok(*SpecifiedValue::parse(context, input)?)) + input.parse_comma_separated(|input| Ok(*SpecifiedValue::parse(input)?)) }).unwrap_or(vec![]); - Ok(PaintWorklet { - name: name, - arguments: arguments, - }) + Ok(PaintWorklet { name, arguments }) }) } } diff --git a/servo/tests/unit/style/custom_properties.rs b/servo/tests/unit/style/custom_properties.rs new file mode 100644 index 000000000000..135583e9d62a --- /dev/null +++ b/servo/tests/unit/style/custom_properties.rs @@ -0,0 +1,49 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +use cssparser::{Parser, ParserInput}; +use servo_arc::Arc; +use style::custom_properties::{self, Name, SpecifiedValue, CustomPropertiesMap}; +use style::properties::DeclaredValue; +use test::{self, Bencher}; + +fn cascade( + name_and_value: &[(&str, &str)], + inherited: Option<&Arc>, +) -> Option> { + let values = name_and_value.iter().map(|&(name, value)| { + let mut input = ParserInput::new(value); + let mut parser = Parser::new(&mut input); + (Name::from(name), SpecifiedValue::parse(&mut parser).unwrap()) + }).collect::>(); + + let mut custom_properties = None; + let mut seen = Default::default(); + for &(ref name, ref val) in &values { + custom_properties::cascade( + &mut custom_properties, + inherited, + &mut seen, + name, + DeclaredValue::Value(val) + ) + } + + custom_properties::finish_cascade(custom_properties, inherited) +} + +#[bench] +fn cascade_custom_simple(b: &mut Bencher) { + b.iter(|| { + let parent = cascade(&[ + ("foo", "10px"), + ("bar", "100px"), + ], None); + + test::black_box(cascade(&[ + ("baz", "calc(40em + 4px)"), + ("bazz", "calc(30em + 4px)"), + ], parent.as_ref())) + }) +} diff --git a/servo/tests/unit/style/lib.rs b/servo/tests/unit/style/lib.rs index f1774fe1a094..c1eab17d1b60 100644 --- a/servo/tests/unit/style/lib.rs +++ b/servo/tests/unit/style/lib.rs @@ -24,6 +24,7 @@ extern crate test; mod animated_properties; mod attr; +mod custom_properties; mod keyframes; mod logical_geometry; mod media_queries; From c6f1bb24ed53f62bdfbc6e0f313bf7555cf4943d Mon Sep 17 00:00:00 2001 From: Stuart Nelson Date: Sun, 8 Oct 2017 07:47:50 -0500 Subject: [PATCH 04/15] servo: Merge #18758 - Add support for dynamic bgcolor change (from stuartnelson3:stn/dynamic-body-bgcolor); r=emilio - [x] `./mach build -d` does not report any errors - [x] `./mach test-tidy` does not report any errors - [x] There are tests for these changes Source-Repo: https://github.com/servo/servo Source-Revision: 712d32e899fd7209f11a422573e18c724ecc65d8 --HG-- extra : subtree_source : https%3A//hg.mozilla.org/projects/converted-servo-linear extra : subtree_revision : b59dfaf587f3e8877a85358ad42a3481f54e5519 --- servo/components/script/dom/htmlbodyelement.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/servo/components/script/dom/htmlbodyelement.rs b/servo/components/script/dom/htmlbodyelement.rs index 4ade5560700b..53fb0637b0df 100644 --- a/servo/components/script/dom/htmlbodyelement.rs +++ b/servo/components/script/dom/htmlbodyelement.rs @@ -125,6 +125,14 @@ impl VirtualMethods for HTMLBodyElement { Some(self.upcast::() as &VirtualMethods) } + fn attribute_affects_presentational_hints(&self, attr: &Attr) -> bool { + if attr.local_name() == &local_name!("bgcolor") { + return true; + } + + self.super_type().unwrap().attribute_affects_presentational_hints(attr) + } + fn bind_to_tree(&self, tree_in_doc: bool) { if let Some(ref s) = self.super_type() { s.bind_to_tree(tree_in_doc); From 224831f7e4279fb545ececafb7e19e889aac4a76 Mon Sep 17 00:00:00 2001 From: Ethan Lin Date: Fri, 6 Oct 2017 14:50:33 +0800 Subject: [PATCH 05/15] Bug 1406306 - Part1. Repaint items when scale is changed. r=jrmuizel MozReview-Commit-ID: LelAXxnxeRb --HG-- extra : rebase_source : 5a732a6498887f5e0adac1378f799f6c40157179 --- gfx/layers/wr/WebRenderCommandBuilder.cpp | 4 +++- gfx/layers/wr/WebRenderUserData.h | 3 +++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/gfx/layers/wr/WebRenderCommandBuilder.cpp b/gfx/layers/wr/WebRenderCommandBuilder.cpp index d4b1722756e5..943c35625829 100644 --- a/gfx/layers/wr/WebRenderCommandBuilder.cpp +++ b/gfx/layers/wr/WebRenderCommandBuilder.cpp @@ -444,7 +444,8 @@ WebRenderCommandBuilder::GenerateFallbackData(nsDisplayItem* aItem, // nsDisplayFilter is rendered via BasicLayerManager which means the invalidate // region is unknown until we traverse the displaylist contained by it. if (geometry && !fallbackData->IsInvalid() && - aItem->GetType() != DisplayItemType::TYPE_FILTER) { + aItem->GetType() != DisplayItemType::TYPE_FILTER && + scale == fallbackData->GetScale()) { nsRect invalid; nsRegion invalidRegion; @@ -516,6 +517,7 @@ WebRenderCommandBuilder::GenerateFallbackData(nsDisplayItem* aItem, } geometry = aItem->AllocateGeometry(aDisplayListBuilder); + fallbackData->SetScale(scale); fallbackData->SetInvalid(false); } diff --git a/gfx/layers/wr/WebRenderUserData.h b/gfx/layers/wr/WebRenderUserData.h index f86a903fa967..7998a124de8b 100644 --- a/gfx/layers/wr/WebRenderUserData.h +++ b/gfx/layers/wr/WebRenderUserData.h @@ -123,6 +123,8 @@ public: nsRect GetBounds() { return mBounds; } void SetBounds(const nsRect& aRect) { mBounds = aRect; } void SetInvalid(bool aInvalid) { mInvalid = aInvalid; } + void SetScale(gfx::Size aScale) { mScale = aScale; } + gfx::Size GetScale() { return mScale; } bool IsInvalid() { return mInvalid; } RefPtr mBasicLayerManager; @@ -130,6 +132,7 @@ protected: nsAutoPtr mGeometry; nsRect mBounds; bool mInvalid; + gfx::Size mScale; }; class WebRenderAnimationData : public WebRenderUserData From f9cf13cd75053ab8fcaa03b47174eb7197190426 Mon Sep 17 00:00:00 2001 From: Ethan Lin Date: Fri, 6 Oct 2017 15:39:51 +0800 Subject: [PATCH 06/15] Bug 1406306 - Part2. Update reftest.list after the fix. r=jrmuizel MozReview-Commit-ID: ILxmYcbFFk1 --HG-- extra : rebase_source : 691c0f51be96eed6cf089daf052c5ea45ecb03a4 --- layout/reftests/bugs/reftest.list | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/layout/reftests/bugs/reftest.list b/layout/reftests/bugs/reftest.list index dc4ff30099cb..379998b76494 100644 --- a/layout/reftests/bugs/reftest.list +++ b/layout/reftests/bugs/reftest.list @@ -1637,7 +1637,7 @@ HTTP(..) == 615121-1.html 615121-1-ref.html HTTP(..) != 615121-2.html 615121-2-notref.html == 617242-1.html 617242-1-ref.html != 618071.html 618071-notref.html -fails-if(webrender) == 619117-1.html 619117-1-ref.html +== 619117-1.html 619117-1-ref.html HTTP(..) == 619511-1.html 619511-1-ref.html skip-if(Android) HTTP(..) == 621253-1-externalFilter.html 621253-1-ref.html skip-if(Android) == 621253-1-internalFilter.html 621253-1-ref.html @@ -1815,7 +1815,7 @@ fuzzy-if(skiaContent,1,80) == 961887-1.html 961887-1-ref.html pref(layout.css.overflow-clip-box.enabled,true) fuzzy(50,145) fuzzy-if(asyncPan&&!layersGPUAccelerated,102,3712) fails-if(webrender) == 966992-1.html 966992-1-ref.html skip-if(Android) == 966510-1.html 966510-1-ref.html # scrollable elements other than the root probably won't work well on android until bug 776030 is fixed skip-if(Android) == 966510-2.html 966510-2-ref.html # same as above -fuzzy-if(skiaContent,1,123) fails-if(webrender) == 978911-1.svg 978911-1-ref.svg +fuzzy-if(skiaContent,1,123) == 978911-1.svg 978911-1-ref.svg == 983084-1.html 983084-1-ref.html == 983084-2.html 983084-2-ref.html == 983084-3.html 983084-1-ref.html From 49ddbca093235dcf9ab17a57d992ac1e1edb36f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= Date: Sun, 8 Oct 2017 09:50:04 -0500 Subject: [PATCH 07/15] servo: Merge #18783 - style: Introduce CustomPropertiesBuilder (from emilio:custom-props-builder); r=SimonSapin I'm about to introduce more state here to implement optimizations for custom property cascading, so this abstraction is useful to encapsulate that state. Source-Repo: https://github.com/servo/servo Source-Revision: 55a37930b218713fff4ba84b4fa1e43a0455e498 --HG-- extra : subtree_source : https%3A//hg.mozilla.org/projects/converted-servo-linear extra : subtree_revision : 836b42e1e79da3ddb1f695622c4b23920fd90c22 --- servo/components/style/custom_properties.rs | 70 ++++++++++++++----- .../style/properties/declaration_block.rs | 18 ++--- .../style/properties/properties.mako.rs | 32 ++++----- servo/tests/unit/style/custom_properties.rs | 16 ++--- 4 files changed, 73 insertions(+), 63 deletions(-) diff --git a/servo/components/style/custom_properties.rs b/servo/components/style/custom_properties.rs index 7fd74f83c1be..ca6e820335b7 100644 --- a/servo/components/style/custom_properties.rs +++ b/servo/components/style/custom_properties.rs @@ -457,9 +457,59 @@ fn parse_var_function<'i, 't>( Ok(()) } +/// A struct that takes care of encapsulating the cascade process for custom +/// properties. +pub struct CustomPropertiesBuilder<'a> { + seen: PrecomputedHashSet<&'a Name>, + custom_properties: Option>>, + inherited: Option<&'a Arc>, +} + +impl<'a> CustomPropertiesBuilder<'a> { + /// Create a new builder, inheriting from a given custom properties map. + pub fn new(inherited: Option<&'a Arc>) -> Self { + Self { + seen: PrecomputedHashSet::default(), + custom_properties: None, + inherited, + } + } + + /// Cascade a given custom property declaration. + pub fn cascade( + &mut self, + name: &'a Name, + specified_value: DeclaredValue<'a, Box>, + ) { + cascade( + &mut self.custom_properties, + self.inherited, + &mut self.seen, + name, + specified_value, + ) + } + + /// Returns the final map of applicable custom properties. + /// + /// If there was any specified property, we've created a new map and now we need + /// to remove any potential cycles, and wrap it in an arc. + /// + /// Otherwise, just use the inherited custom properties map. + pub fn build(mut self) -> Option> { + let mut map = match self.custom_properties.take() { + Some(map) => map, + None => return self.inherited.cloned(), + }; + + remove_cycles(&mut map); + Some(Arc::new(substitute_all(map))) + } +} + /// Add one custom property declaration to a map, unless another with the same /// name was already there. -pub fn cascade<'a>( +fn cascade<'a>( custom_properties: &mut Option>>, inherited: Option<&'a Arc>, seen: &mut PrecomputedHashSet<&'a Name>, @@ -509,24 +559,6 @@ pub fn cascade<'a>( } } -/// Returns the final map of applicable custom properties. -/// -/// If there was any specified property, we've created a new map and now we need -/// to remove any potential cycles, and wrap it in an arc. -/// -/// Otherwise, just use the inherited custom properties map. -pub fn finish_cascade( - specified_values_map: Option>, - inherited: Option<&Arc>, -) -> Option> { - if let Some(mut map) = specified_values_map { - remove_cycles(&mut map); - Some(Arc::new(substitute_all(map))) - } else { - inherited.cloned() - } -} - /// https://drafts.csswg.org/css-variables/#cycles /// /// The initial value of a custom property is represented by this property not diff --git a/servo/components/style/properties/declaration_block.rs b/servo/components/style/properties/declaration_block.rs index b1c7d547bbb4..df4840f0dda1 100644 --- a/servo/components/style/properties/declaration_block.rs +++ b/servo/components/style/properties/declaration_block.rs @@ -9,6 +9,7 @@ use context::QuirksMode; use cssparser::{DeclarationListParser, parse_important, ParserInput, CowRcStr}; use cssparser::{Parser, AtRuleParser, DeclarationParser, Delimiter, ParseError as CssParseError}; +use custom_properties::CustomPropertiesBuilder; use error_reporting::{ParseErrorReporter, ContextualParseError}; use parser::{ParserContext, ParserErrorContext}; use properties::animated_properties::AnimationValue; @@ -691,24 +692,15 @@ impl PropertyDeclarationBlock { &self, inherited_custom_properties: Option<&Arc<::custom_properties::CustomPropertiesMap>>, ) -> Option> { - let mut custom_properties = None; - let mut seen_custom = PrecomputedHashSet::default(); + let mut builder = CustomPropertiesBuilder::new(inherited_custom_properties); for declaration in self.normal_declaration_iter() { if let PropertyDeclaration::Custom(ref name, ref value) = *declaration { - ::custom_properties::cascade( - &mut custom_properties, - inherited_custom_properties, - &mut seen_custom, - name, - value.borrow(), - ); + builder.cascade(name, value.borrow()); } } - ::custom_properties::finish_cascade( - custom_properties, - inherited_custom_properties, - ) + + builder.build() } } diff --git a/servo/components/style/properties/properties.mako.rs b/servo/components/style/properties/properties.mako.rs index 031bd1e580b6..d18bacbb6311 100644 --- a/servo/components/style/properties/properties.mako.rs +++ b/servo/components/style/properties/properties.mako.rs @@ -12,6 +12,7 @@ #[cfg(feature = "servo")] use app_units::Au; +use custom_properties::CustomPropertiesBuilder; use servo_arc::{Arc, UniqueArc}; use smallbitvec::SmallBitVec; use std::borrow::Cow; @@ -33,7 +34,6 @@ use media_queries::Device; use parser::ParserContext; #[cfg(feature = "gecko")] use properties::longhands::system_font::SystemFont; use rule_cache::{RuleCache, RuleCacheConditions}; -use selector_map::PrecomputedHashSet; use selector_parser::PseudoElement; use selectors::parser::SelectorParseError; #[cfg(feature = "servo")] use servo_config::prefs::PREFS; @@ -3228,26 +3228,18 @@ where } }; - let inherited_custom_properties = inherited_style.custom_properties(); - let mut custom_properties = None; - let mut seen_custom = PrecomputedHashSet::default(); - for (declaration, _cascade_level) in iter_declarations() { - if let PropertyDeclaration::Custom(ref name, ref value) = *declaration { - ::custom_properties::cascade( - &mut custom_properties, - inherited_custom_properties, - &mut seen_custom, - name, - value.borrow(), - ); - } - } + let custom_properties = { + let mut builder = + CustomPropertiesBuilder::new(inherited_style.custom_properties()); - let custom_properties = - ::custom_properties::finish_cascade( - custom_properties, - inherited_custom_properties, - ); + for (declaration, _cascade_level) in iter_declarations() { + if let PropertyDeclaration::Custom(ref name, ref value) = *declaration { + builder.cascade(name, value.borrow()); + } + } + + builder.build() + }; let mut context = computed::Context { is_root_element: flags.contains(IS_ROOT_ELEMENT), diff --git a/servo/tests/unit/style/custom_properties.rs b/servo/tests/unit/style/custom_properties.rs index 135583e9d62a..7a2741633c87 100644 --- a/servo/tests/unit/style/custom_properties.rs +++ b/servo/tests/unit/style/custom_properties.rs @@ -4,7 +4,7 @@ use cssparser::{Parser, ParserInput}; use servo_arc::Arc; -use style::custom_properties::{self, Name, SpecifiedValue, CustomPropertiesMap}; +use style::custom_properties::{Name, SpecifiedValue, CustomPropertiesMap, CustomPropertiesBuilder}; use style::properties::DeclaredValue; use test::{self, Bencher}; @@ -18,19 +18,13 @@ fn cascade( (Name::from(name), SpecifiedValue::parse(&mut parser).unwrap()) }).collect::>(); - let mut custom_properties = None; - let mut seen = Default::default(); + let mut builder = CustomPropertiesBuilder::new(inherited); + for &(ref name, ref val) in &values { - custom_properties::cascade( - &mut custom_properties, - inherited, - &mut seen, - name, - DeclaredValue::Value(val) - ) + builder.cascade(name, DeclaredValue::Value(val)); } - custom_properties::finish_cascade(custom_properties, inherited) + builder.build() } #[bench] From 00c6bbf432dab7e781ff2d3444806072e1522765 Mon Sep 17 00:00:00 2001 From: Gerald Squelart Date: Mon, 28 Aug 2017 10:37:44 +1200 Subject: [PATCH 08/15] Bug 1394995 - Moved DecoderDoctor files to dom/media/doctor/ - r=jwwang MozReview-Commit-ID: 9fEmeizzAAw --HG-- rename : dom/media/DecoderDoctorDiagnostics.cpp => dom/media/doctor/DecoderDoctorDiagnostics.cpp rename : dom/media/DecoderDoctorDiagnostics.h => dom/media/doctor/DecoderDoctorDiagnostics.h extra : rebase_source : 38d149815101f222bd42aec7c2f481768c7ab335 --- .../{ => doctor}/DecoderDoctorDiagnostics.cpp | 0 dom/media/{ => doctor}/DecoderDoctorDiagnostics.h | 0 dom/media/doctor/moz.build | 15 +++++++++++++++ dom/media/moz.build | 3 +-- 4 files changed, 16 insertions(+), 2 deletions(-) rename dom/media/{ => doctor}/DecoderDoctorDiagnostics.cpp (100%) rename dom/media/{ => doctor}/DecoderDoctorDiagnostics.h (100%) create mode 100644 dom/media/doctor/moz.build diff --git a/dom/media/DecoderDoctorDiagnostics.cpp b/dom/media/doctor/DecoderDoctorDiagnostics.cpp similarity index 100% rename from dom/media/DecoderDoctorDiagnostics.cpp rename to dom/media/doctor/DecoderDoctorDiagnostics.cpp diff --git a/dom/media/DecoderDoctorDiagnostics.h b/dom/media/doctor/DecoderDoctorDiagnostics.h similarity index 100% rename from dom/media/DecoderDoctorDiagnostics.h rename to dom/media/doctor/DecoderDoctorDiagnostics.h diff --git a/dom/media/doctor/moz.build b/dom/media/doctor/moz.build new file mode 100644 index 000000000000..8dad4d71b1d1 --- /dev/null +++ b/dom/media/doctor/moz.build @@ -0,0 +1,15 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +EXPORTS += [ + 'DecoderDoctorDiagnostics.h', +] + +UNIFIED_SOURCES += [ + 'DecoderDoctorDiagnostics.cpp', +] + +FINAL_LIBRARY = 'xul' diff --git a/dom/media/moz.build b/dom/media/moz.build index 81d413ae3c0b..ad95160beab1 100644 --- a/dom/media/moz.build +++ b/dom/media/moz.build @@ -32,6 +32,7 @@ with Files('GetUserMedia*'): BUG_COMPONENT = component_av DIRS += [ + 'doctor', 'eme', 'encoder', 'fake-cdm', @@ -101,7 +102,6 @@ EXPORTS += [ 'BufferMediaResource.h', 'ChannelMediaDecoder.h', 'CubebUtils.h', - 'DecoderDoctorDiagnostics.h', 'DecoderTraits.h', 'DOMMediaStream.h', 'FileBlockCache.h', @@ -216,7 +216,6 @@ UNIFIED_SOURCES += [ 'ChannelMediaResource.cpp', 'CloneableWithRangeMediaResource.cpp', 'CubebUtils.cpp', - 'DecoderDoctorDiagnostics.cpp', 'DOMMediaStream.cpp', 'FileBlockCache.cpp', 'FileMediaResource.cpp', From 43a5a26e7bdf08660b659be3e7cf8299eaae3224 Mon Sep 17 00:00:00 2001 From: Gerald Squelart Date: Fri, 15 Sep 2017 14:31:13 +1200 Subject: [PATCH 09/15] Bug 1394995 - RollingNumber - r=jwwang Unsigned-number value-class with modified comparison operators that keep ordering consistent across overflows. I.e., numbers before the overflow (close to the maximum) will be considered smaller than numbers after the overflow (close to 0). (Note that such comparisons break down for numbers separated by more than half the type range.) MozReview-Commit-ID: 1hdK2JknlqZ --HG-- extra : rebase_source : 7be3c1be6bc846e17dd5b396fcf097076b9096c1 --- dom/media/doctor/RollingNumber.h | 182 +++++++++++++++++++ dom/media/doctor/gtest/TestRollingNumber.cpp | 146 +++++++++++++++ dom/media/doctor/gtest/moz.build | 20 ++ dom/media/doctor/moz.build | 4 + 4 files changed, 352 insertions(+) create mode 100644 dom/media/doctor/RollingNumber.h create mode 100644 dom/media/doctor/gtest/TestRollingNumber.cpp create mode 100644 dom/media/doctor/gtest/moz.build diff --git a/dom/media/doctor/RollingNumber.h b/dom/media/doctor/RollingNumber.h new file mode 100644 index 000000000000..26d35f5f26ef --- /dev/null +++ b/dom/media/doctor/RollingNumber.h @@ -0,0 +1,182 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_RollingNumber_h_ +#define mozilla_RollingNumber_h_ + +#include "mozilla/Attributes.h" +#include + +namespace mozilla { + +// Unsigned number suited to index elements in a never-ending queue, as +// order-comparison behaves nicely around the overflow. +// +// Additive operators work the same as for the underlying value type, but +// expect "small" jumps, as should normally happen when manipulating indices. +// +// Comparison functions are different, they keep the ordering based on the +// distance between numbers, modulo the value type range: +// If the distance is less than half the range of the value type, the usual +// ordering stays. +// 0 < 1, 2^23 < 2^24 +// However if the distance is more than half the range, we assume that we are +// continuing along the queue, and therefore consider the smaller number to +// actually be greater! +// uint(-1) < 0. +// +// The expected usage is to always work on nearby rolling numbers: slowly +// incrementing/decrementing them, and translating&comparing them within a +// small window. +// To enforce this usage during development, debug-build assertions catch API +// calls involving distances of more than a *quarter* of the type range. +// In non-debug builds, all APIs will still work as consistently as possible +// without crashing, but performing operations on "distant" nunbers could lead +// to unexpected results. +template +class RollingNumber +{ + static_assert(!std::numeric_limits::is_signed, + "RollingNumber only accepts unsigned number types"); + +public: + using ValueType = T; + + RollingNumber() + : mIndex(0) + { + } + + explicit RollingNumber(ValueType aIndex) + : mIndex(aIndex) + { + } + + RollingNumber(const RollingNumber&) = default; + RollingNumber& operator=(const RollingNumber&) = default; + + ValueType Value() const { return mIndex; } + + // Normal increments/decrements. + + RollingNumber& operator++() + { + ++mIndex; + return *this; + } + + RollingNumber operator++(int) { return RollingNumber{ mIndex++ }; } + + RollingNumber& operator--() + { + --mIndex; + return *this; + } + + RollingNumber operator--(int) { return RollingNumber{ mIndex-- }; } + + RollingNumber& operator+=(const ValueType& aIncrement) + { + MOZ_ASSERT(aIncrement <= MaxDiff); + mIndex += aIncrement; + return *this; + } + + RollingNumber operator+(const ValueType& aIncrement) const + { + RollingNumber n = *this; + return n += aIncrement; + } + + RollingNumber& operator-=(const ValueType& aDecrement) + { + MOZ_ASSERT(aDecrement <= MaxDiff); + mIndex -= aDecrement; + return *this; + } + + // Translate a RollingNumber by a negative value. + RollingNumber operator-(const ValueType& aDecrement) const + { + RollingNumber n = *this; + return n -= aDecrement; + } + + // Distance between two RollingNumbers, giving a value. + ValueType operator-(const RollingNumber& aOther) const + { + ValueType diff = mIndex - aOther.mIndex; + MOZ_ASSERT(diff <= MaxDiff); + return diff; + } + + // Normal (in)equality operators. + + bool operator==(const RollingNumber& aOther) const + { + return mIndex == aOther.mIndex; + } + bool operator!=(const RollingNumber& aOther) const + { + return !(*this == aOther); + } + + // Modified comparison operators. + + bool operator<(const RollingNumber& aOther) const + { + const T& a = mIndex; + const T& b = aOther.mIndex; + // static_cast needed because of possible integer promotion + // (e.g., from uint8_t to int, which would make the test useless). + const bool lessThanOther = static_cast(a - b) > MidWay; + MOZ_ASSERT((lessThanOther ? (b - a) : (a - b)) <= MaxDiff); + return lessThanOther; + } + + bool operator<=(const RollingNumber& aOther) const + { + const T& a = mIndex; + const T& b = aOther.mIndex; + const bool lessishThanOther = static_cast(b - a) <= MidWay; + MOZ_ASSERT((lessishThanOther ? (b - a) : (a - b)) <= MaxDiff); + return lessishThanOther; + } + + bool operator>=(const RollingNumber& aOther) const + { + const T& a = mIndex; + const T& b = aOther.mIndex; + const bool greaterishThanOther = static_cast(a - b) <= MidWay; + MOZ_ASSERT((greaterishThanOther ? (a - b) : (b - a)) <= MaxDiff); + return greaterishThanOther; + } + + bool operator>(const RollingNumber& aOther) const + { + const T& a = mIndex; + const T& b = aOther.mIndex; + const bool greaterThanOther = static_cast(b - a) > MidWay; + MOZ_ASSERT((greaterThanOther ? (a - b) : (b - a)) <= MaxDiff); + return greaterThanOther; + } + +private: + // MidWay is used to split the type range in two, to decide how two numbers + // are ordered. + static const T MidWay = std::numeric_limits::max() / 2; +#ifdef DEBUG + // MaxDiff is the expected maximum difference between two numbers, either + // during comparisons, or when adding/subtracting. + // This is only used during debugging, to highlight algorithmic issues. + static const T MaxDiff = std::numeric_limits::max() / 4; +#endif + ValueType mIndex; +}; + +} // namespace mozilla + +#endif // mozilla_RollingNumber_h_ diff --git a/dom/media/doctor/gtest/TestRollingNumber.cpp b/dom/media/doctor/gtest/TestRollingNumber.cpp new file mode 100644 index 000000000000..10718311ab92 --- /dev/null +++ b/dom/media/doctor/gtest/TestRollingNumber.cpp @@ -0,0 +1,146 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "RollingNumber.h" + +#include "mozilla/Assertions.h" +#include "mozilla/TypeTraits.h" + +#include +#include + +using RN8 = mozilla::RollingNumber; + +TEST(RollingNumber, Value) +{ + // Value type should reflect template argument. + static_assert(mozilla::IsSame::value, ""); + + // Default init to 0. + const RN8 n; + // Access through Value(). + EXPECT_EQ(0, n.Value()); + + // Conversion constructor. + RN8 n42{ 42 }; + EXPECT_EQ(42, n42.Value()); + + // Copy Constructor. + RN8 n42Copied{ n42 }; + EXPECT_EQ(42, n42Copied.Value()); + + // Assignment construction. + RN8 n42Assigned = n42; + EXPECT_EQ(42, n42Assigned.Value()); + + // Assignment. + n42 = n; + EXPECT_EQ(0, n42.Value()); +} + +TEST(RollingNumber, Operations) +{ + RN8 n; + EXPECT_EQ(0, n.Value()); + + RN8 nPreInc = ++n; + EXPECT_EQ(1, n.Value()); + EXPECT_EQ(1, nPreInc.Value()); + + RN8 nPostInc = n++; + EXPECT_EQ(2, n.Value()); + EXPECT_EQ(1, nPostInc.Value()); + + RN8 nPreDec = --n; + EXPECT_EQ(1, n.Value()); + EXPECT_EQ(1, nPreDec.Value()); + + RN8 nPostDec = n--; + EXPECT_EQ(0, n.Value()); + EXPECT_EQ(1, nPostDec.Value()); + + RN8 nPlus = n + 10; + EXPECT_EQ(0, n.Value()); + EXPECT_EQ(10, nPlus.Value()); + + n += 20; + EXPECT_EQ(20, n.Value()); + + RN8 nMinus = n - 2; + EXPECT_EQ(20, n.Value()); + EXPECT_EQ(18, nMinus.Value()); + + n -= 5; + EXPECT_EQ(15, n.Value()); + + uint8_t diff = nMinus - n; + EXPECT_EQ(3, diff); + + // Overflows. + n = RN8(0); + EXPECT_EQ(0, n.Value()); + n--; + EXPECT_EQ(255, n.Value()); + n++; + EXPECT_EQ(0, n.Value()); + n -= 10; + EXPECT_EQ(246, n.Value()); + n += 20; + EXPECT_EQ(10, n.Value()); +} + +TEST(RollingNumber, Comparisons) +{ + uint8_t i = 0; + do { + RN8 n{ i }; + EXPECT_EQ(i, n.Value()); + EXPECT_TRUE(n == n); + EXPECT_FALSE(n != n); + EXPECT_FALSE(n < n); + EXPECT_TRUE(n <= n); + EXPECT_FALSE(n > n); + EXPECT_TRUE(n >= n); + + RN8 same = n; + EXPECT_TRUE(n == same); + EXPECT_FALSE(n != same); + EXPECT_FALSE(n < same); + EXPECT_TRUE(n <= same); + EXPECT_FALSE(n > same); + EXPECT_TRUE(n >= same); + +#ifdef DEBUG + // In debug builds, we are only allowed a quarter of the type range. + const uint8_t maxDiff = 255 / 4; +#else + // In non-debug builds, we can go half-way up or down the type range, and + // still conserve the expected ordering. + const uint8_t maxDiff = 255 / 2; +#endif + for (uint8_t add = 1; add <= maxDiff; ++add) { + RN8 bigger = n + add; + EXPECT_FALSE(n == bigger); + EXPECT_TRUE(n != bigger); + EXPECT_TRUE(n < bigger); + EXPECT_TRUE(n <= bigger); + EXPECT_FALSE(n > bigger); + EXPECT_FALSE(n >= bigger); + } + + for (uint8_t sub = 1; sub <= maxDiff; ++sub) { + RN8 smaller = n - sub; + EXPECT_FALSE(n == smaller); + EXPECT_TRUE(n != smaller); + EXPECT_FALSE(n < smaller); + EXPECT_FALSE(n <= smaller); + EXPECT_TRUE(n > smaller); + EXPECT_TRUE(n >= smaller); + } + + ++i; + } while (i != 0); +} diff --git a/dom/media/doctor/gtest/moz.build b/dom/media/doctor/gtest/moz.build new file mode 100644 index 000000000000..17a5f37bdedb --- /dev/null +++ b/dom/media/doctor/gtest/moz.build @@ -0,0 +1,20 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +UNIFIED_SOURCES += [ + 'TestRollingNumber.cpp', +] + +include('/ipc/chromium/chromium-config.mozbuild') + +LOCAL_INCLUDES += [ + '/dom/media/doctor', +] + +FINAL_LIBRARY = 'xul-gtest' + +if CONFIG['GNU_CXX']: + CXXFLAGS += ['-Wno-error=shadow'] diff --git a/dom/media/doctor/moz.build b/dom/media/doctor/moz.build index 8dad4d71b1d1..a2a149aa2eaa 100644 --- a/dom/media/doctor/moz.build +++ b/dom/media/doctor/moz.build @@ -4,6 +4,10 @@ # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. +TEST_DIRS += [ + 'gtest', +] + EXPORTS += [ 'DecoderDoctorDiagnostics.h', ] From fb0f980782863f6fe1cba7cc8fb124f258f16498 Mon Sep 17 00:00:00 2001 From: Gerald Squelart Date: Fri, 15 Sep 2017 15:10:17 +1200 Subject: [PATCH 10/15] Bug 1394995 - MultiWriterQueue - r=jwwang Templated queue allowing safe and fast multi-threaded pushes. Popping is not thread-safe (but concurrent pushes are still allowed.) MozReview-Commit-ID: BHQ3nOlHkLX --HG-- extra : rebase_source : 4a5dd6b603cbfe9bdd86df339469e870761d742a --- dom/media/doctor/MultiWriterQueue.h | 534 ++++++++++++++++++ .../doctor/gtest/TestMultiWriterQueue.cpp | 400 +++++++++++++ dom/media/doctor/gtest/moz.build | 1 + 3 files changed, 935 insertions(+) create mode 100644 dom/media/doctor/MultiWriterQueue.h create mode 100644 dom/media/doctor/gtest/TestMultiWriterQueue.cpp diff --git a/dom/media/doctor/MultiWriterQueue.h b/dom/media/doctor/MultiWriterQueue.h new file mode 100644 index 000000000000..87b9cbdc5951 --- /dev/null +++ b/dom/media/doctor/MultiWriterQueue.h @@ -0,0 +1,534 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_MultiWriterQueue_h_ +#define mozilla_MultiWriterQueue_h_ + +#include "mozilla/Atomics.h" +#include "mozilla/Move.h" +#include "mozilla/Mutex.h" +#include "prthread.h" +#include "RollingNumber.h" +#include + +namespace mozilla { + +// Default reader locking strategy, using a mutex to ensure that concurrent +// PopAll calls won't overlap. +class MultiWriterQueueReaderLocking_Mutex +{ +public: + MultiWriterQueueReaderLocking_Mutex() + : mMutex("MultiWriterQueueReaderLocking_Mutex") + { + } + void Lock() { mMutex.Lock(); }; + void Unlock() { mMutex.Unlock(); }; + +private: + Mutex mMutex; +}; + +// Reader non-locking strategy, trusting that PopAll will never be called +// concurrently (e.g., by only calling it from a specific thread). +class MultiWriterQueueReaderLocking_None +{ +public: +#ifndef DEBUG + void Lock(){}; + void Unlock(){}; +#else + // DEBUG-mode checks to catch concurrent misuses. + void Lock() { MOZ_ASSERT(mLocked.compareExchange(false, true)); }; + void Unlock() { MOZ_ASSERT(mLocked.compareExchange(true, false)); }; + +private: + Atomic mLocked{ false }; +#endif +}; + +static constexpr uint32_t MultiWriterQueueDefaultBufferSize = 8192; + +// Multi-writer, single-reader queue of elements of type `T`. +// Elements are bunched together in buffers of `BufferSize` elements. +// +// This queue is heavily optimized for pushing. In most cases pushes will only +// cost a couple of atomic reads and a few non-atomic reads. Worst cases: +// - Once per buffer, a push will allocate or reuse a buffer for later pushes; +// - During the above new-buffer push, other pushes will be blocked. +// +// By default, popping is protected by mutex; it may be disabled if popping is +// guaranteed never to be concurrent. +// In any case, popping will never negatively impact pushes. +// (However, *not* popping will add runtime costs, as unread buffers will not +// be freed, or made available to future pushes; Push functions provide +// feedback as to when popping would be most efficient.) +template +class MultiWriterQueue +{ + static_assert(BufferSize > 0, "0-sized MultiWriterQueue buffer"); + +public: + // Constructor. + // Allocates the initial buffer that will receive the first `BufferSize` + // elements. Also allocates one reusable buffer, which will definitely be + // needed after the first `BufferSize` elements have been pushed. + // Ideally (if the reader can process each buffer quickly enough), there + // won't be a need for more buffer allocations. + MultiWriterQueue() + : mBuffersCoverAtLeastUpTo(BufferSize - 1) + , mMostRecentBuffer(new Buffer{}) + , mReusableBuffers(new Buffer{}) + , mOldestBuffer(static_cast(mMostRecentBuffer)) + , mLiveBuffersStats(1) + , mReusableBuffersStats(1) + , mAllocatedBuffersStats(2) + { + } + + ~MultiWriterQueue() + { + auto DestroyList = [](Buffer* aBuffer) + { + while (aBuffer) { + Buffer* older = aBuffer->Older(); + delete aBuffer; + aBuffer = older; + } + }; + DestroyList(mMostRecentBuffer); + DestroyList(mReusableBuffers); + } + + // We need the index to be order-resistant to overflow, i.e., numbers before + // an overflow should test smaller-than numbers after the overflow. + // This is because we keep pushing elements with increasing Index, and this + // Index is used to find the appropriate buffer based on a range; and this + // need to work smoothly when crossing the overflow boundary. + using Index = RollingNumber; + + // Pushes indicate whether they have just reached the end of a buffer. + using DidReachEndOfBuffer = bool; + + // Push new element and call aF on it. + // Element may be in just-created state, or recycled after a PopAll call. + // Atomically thread-safe; in the worst case some pushes may be blocked + // while a new buffer is created/reused for them. + // Returns whether that push reached the end of a buffer; useful if caller + // wants to trigger processing regularly at the most efficient time. + template + DidReachEndOfBuffer PushF(F&& aF) + { + // Atomically claim ownership of the next available element. + const Index index{ mNextElementToWrite++ }; + // And now go and set that element. + for (;;) { + Index lastIndex{ mBuffersCoverAtLeastUpTo }; + + if (MOZ_UNLIKELY(index == lastIndex)) { + // We have claimed the last element in the current head -> Allocate a + // new head in advance of more pushes. Make it point at the current + // most-recent buffer. + // This whole process is effectively guarded: + // - Later pushes will wait until mBuffersCoverAtLeastUpTo changes to + // one that can accept their claimed index. + // - Readers will stop until the last element is marked as valid. + Buffer* ourBuffer = mMostRecentBuffer; + Buffer* newBuffer = NewBuffer(ourBuffer, index + 1); + // Because we have claimed this very specific index, we should be the + // only one touching the most-recent buffer pointer. + MOZ_ASSERT(mMostRecentBuffer == ourBuffer); + // Just pivot the most-recent buffer pointer to our new buffer. + mMostRecentBuffer = newBuffer; + // Because we have claimed this very specific index, we should be the + // only one touching the buffer coverage watermark. + MOZ_ASSERT(mBuffersCoverAtLeastUpTo == lastIndex.Value()); + // Update it to include the just-added most-recent buffer. + mBuffersCoverAtLeastUpTo = index.Value() + BufferSize; + // We know for sure that `ourBuffer` is the correct one for this index. + ourBuffer->SetAndValidateElement(aF, index); + // And indicate that we have reached the end of a buffer. + return true; + } + + if (MOZ_UNLIKELY(index > lastIndex)) { + // We have claimed an element in a yet-unavailable buffer, wait for our + // target buffer to be created (see above). + while (Index(mBuffersCoverAtLeastUpTo) < index) { + PR_Sleep(PR_INTERVAL_NO_WAIT); // Yield + } + // Then loop to examine the new situation. + continue; + } + + // Here, we have claimed a number that is covered by current buffers. + // These buffers cannot be destroyed, because our buffer is not filled + // yet (we haven't written in it yet), therefore the reader thread will + // have to stop there (or before) and won't destroy our buffer or more + // recent ones. + MOZ_ASSERT(index < lastIndex); + Buffer* ourBuffer = mMostRecentBuffer; + + // In rare situations, another thread may have had the time to create a + // new more-recent buffer, in which case we need to find our older buffer. + while (MOZ_UNLIKELY(index < ourBuffer->Origin())) { + // We assume that older buffers with still-invalid elements (e.g., the + // one we have just claimed) cannot be destroyed. + MOZ_ASSERT(ourBuffer->Older()); + ourBuffer = ourBuffer->Older(); + } + + // Now we can set&validate the claimed element, and indicate that we have + // not reached the end of a buffer. + ourBuffer->SetAndValidateElement(aF, index); + return false; + } + } + + // Push new element and assign it a value. + // Atomically thread-safe; in the worst case some pushes may be blocked + // while a new buffer is created/reused for them. + // Returns whether that push reached the end of a buffer; useful if caller + // wants to trigger processing regularly at the most efficient time. + DidReachEndOfBuffer Push(const T& aT) + { + return PushF([&aT](T& aElement, Index) { aElement = aT; }); + } + + // Push new element and move-assign it a value. + // Atomically thread-safe; in the worst case some pushes may be blocked + // while a new buffer is created/reused for them. + // Returns whether that push reached the end of a buffer; useful if caller + // wants to trigger processing regularly at the most efficient time. + DidReachEndOfBuffer Push(T&& aT) + { + return PushF([&aT](T& aElement, Index) { aElement = Move(aT); }); + } + + // Pop all elements before the first invalid one, running aF on each of them + // in FIFO order. + // Thread-safety with other PopAll calls is controlled by the `Locking` + // template argument. + // Concurrent pushes are always allowed, because: + // - PopAll won't read elements until valid, + // - Pushes do not interfere with pop-related members -- except for + // mReusableBuffers, which is accessed atomically. + template + void PopAll(F&& aF) + { + mReaderLocking.Lock(); + // Destroy every second fully-read buffer. + // TODO: Research a better algorithm, probably based on stats. + bool destroy = false; + for (;;) { + Buffer* b = mOldestBuffer; + MOZ_ASSERT(!b->Older()); + // The next element to pop must be in that oldest buffer. + MOZ_ASSERT(mNextElementToPop >= b->Origin()); + MOZ_ASSERT(mNextElementToPop < b->Origin() + BufferSize); + + // Start reading each element. + if (!b->ReadAndInvalidateAll(aF, mNextElementToPop)) { + // Found an invalid element, stop popping. + mReaderLocking.Unlock(); + return; + } + + // Reached the end of this oldest buffer + MOZ_ASSERT(mNextElementToPop == b->Origin() + BufferSize); + // Delete this oldest buffer. + // Since the last element was valid, it must mean that there is a newer + // buffer. + MOZ_ASSERT(b->Newer()); + MOZ_ASSERT(mNextElementToPop == b->Newer()->Origin()); + StopUsing(b, destroy); + destroy = !destroy; + + // We will loop and start reading the now-oldest buffer. + } + } + + struct CountAndWatermark + { + int mCount; + int mWatermark; + }; + + CountAndWatermark LiveBuffersStats() const { return mLiveBuffersStats.Get(); } + CountAndWatermark ReusableBuffersStats() const + { + return mReusableBuffersStats.Get(); + } + CountAndWatermark AllocatedBuffersStats() const + { + return mAllocatedBuffersStats.Get(); + } + +private: + // Structure containing the element to be stored, and a validity-marker. + class BufferedElement + { + public: + // Run aF on an invalid element, and mark it as valid. + template + void SetAndValidate(F&& aF, Index aIndex) + { + MOZ_ASSERT(!mValid); + aF(mT, aIndex); + mValid = true; + } + + // Run aF on a valid element and mark it as invalid, return true. + // Return false if element was invalid. + template + bool ReadAndInvalidate(F&& aF) + { + if (!mValid) { + return false; + } + aF(mT); + mValid = false; + return true; + } + + private: + T mT; + // mValid should be atomically changed to true *after* mT has been written, + // so that the reader can only see valid data. + Atomic mValid{ false }; + }; + + // Buffer contains a sequence of BufferedElements starting at a specific + // index, and it points to the next-older buffer (if any). + class Buffer + { + public: + // Constructor of the very first buffer. + Buffer() + : mOlder(nullptr) + , mNewer(nullptr) + , mOrigin(0) + { + } + + // Constructor of later buffers. + Buffer(Buffer* aOlder, Index aOrigin) + : mOlder(aOlder) + , mNewer(nullptr) + , mOrigin(aOrigin) + { + MOZ_ASSERT(aOlder); + aOlder->mNewer = this; + } + + Buffer* Older() const { return mOlder; } + void SetOlder(Buffer* aOlder) { mOlder = aOlder; } + + Buffer* Newer() const { return mNewer; } + void SetNewer(Buffer* aNewer) { mNewer = aNewer; } + + Index Origin() const { return mOrigin; } + void SetOrigin(Index aOrigin) { mOrigin = aOrigin; } + + // Run aF on a yet-invalid element. + // Not thread-safe by itself, but nothing else should write this element, + // and reader won't access it until after it becomes valid. + template + void SetAndValidateElement(F&& aF, Index aIndex) + { + MOZ_ASSERT(aIndex >= Origin()); + MOZ_ASSERT(aIndex < Origin() + BufferSize); + mElements[aIndex - Origin()].SetAndValidate(aF, aIndex); + } + + using DidReadLastElement = bool; + + // Read all valid elements starting at aIndex, marking them invalid and + // updating aIndex. + // Returns true if we ended up reading the last element in this buffer. + // Accessing the validity bit is thread-safe (as it's atomic), but once + // an element is valid, the reading itself is not thread-safe and should be + // guarded. + template + DidReadLastElement ReadAndInvalidateAll(F&& aF, Index& aIndex) + { + MOZ_ASSERT(aIndex >= Origin()); + MOZ_ASSERT(aIndex < Origin() + BufferSize); + for (; aIndex < Origin() + BufferSize; ++aIndex) { + if (!mElements[aIndex - Origin()].ReadAndInvalidate(aF)) { + // Found an invalid element, stop here. (aIndex will not be updated + // past it, so we will start from here next time.) + return false; + } + } + return true; + } + + private: + Buffer* mOlder; + Buffer* mNewer; + Index mOrigin; + BufferedElement mElements[BufferSize]; + }; + + // Reuse a buffer, or create a new one. + // All buffered elements will be invalid. + Buffer* NewBuffer(Buffer* aOlder, Index aOrigin) + { + MOZ_ASSERT(aOlder); + for (;;) { + Buffer* head = mReusableBuffers; + if (!head) { + ++mAllocatedBuffersStats; + ++mLiveBuffersStats; + Buffer* buffer = new Buffer(aOlder, aOrigin); + return buffer; + } + Buffer* older = head->Older(); + // Try to pivot the reusable-buffer pointer from the current head to the + // next buffer in line. + if (mReusableBuffers.compareExchange(head, older)) { + // Success! The reusable-buffer pointer now points at the older buffer, + // so we can recycle this ex-head. + --mReusableBuffersStats; + ++mLiveBuffersStats; + head->SetOlder(aOlder); + aOlder->SetNewer(head); + // We will be the newest; newer-pointer should already be null. + MOZ_ASSERT(!head->Newer()); + head->SetOrigin(aOrigin); + return head; + } + // Failure, someone else must have touched the list, loop to try again. + } + } + + // Discard a fully-read buffer. + // If aDestroy is true, delete it. + // If aDestroy is false, move the buffer to a reusable-buffer stack. + void StopUsing(Buffer* aBuffer, bool aDestroy) + { + --mLiveBuffersStats; + + // We should only stop using the oldest buffer. + MOZ_ASSERT(!aBuffer->Older()); + // The newest buffer should not be modified here. + MOZ_ASSERT(aBuffer->Newer()); + MOZ_ASSERT(aBuffer->Newer()->Older() == aBuffer); + // Detach from the second-oldest buffer. + aBuffer->Newer()->SetOlder(nullptr); + // Make the second-oldest buffer the now-oldest buffer. + mOldestBuffer = aBuffer->Newer(); + + if (aDestroy) { + --mAllocatedBuffersStats; + delete aBuffer; + } else { + ++mReusableBuffersStats; + // The recycling stack only uses mOlder; mNewer is not needed. + aBuffer->SetNewer(nullptr); + + // Make the given buffer the new head of reusable buffers. + for (;;) { + Buffer* head = mReusableBuffers; + aBuffer->SetOlder(head); + if (mReusableBuffers.compareExchange(head, aBuffer)) { + break; + } + } + } + } + + // Index of the next element to write. Modified when an element index is + // claimed for a push. If the last element of a buffer is claimed, that push + // will be responsible for adding a new head buffer. + Atomic mNextElementToWrite{ 0 }; + + // Index that a live recent buffer reaches. If a push claims a lesser-or- + // equal number, the corresponding buffer is guaranteed to still be alive: + // - It will have been created before this index was updated, + // - It will not be destroyed until all its values have been written, + // including the one that just claimed a position within it. + // Also, the push that claims this exact number is responsible for adding the + // next buffer and updating this value accordingly. + Atomic mBuffersCoverAtLeastUpTo; + + // Pointer to the most recent buffer. Never null. + // This is the most recent of a deque of yet-unread buffers. + // Only modified when adding a new head buffer. + Atomic mMostRecentBuffer; + + // Stack of reusable buffers. + Atomic mReusableBuffers; + + // Template-provided locking mechanism to protect PopAll()-only member + // variables below. + ReaderLocking mReaderLocking; + + // Pointer to the oldest buffer, which contains the new element to be popped. + // Never null. + Buffer* mOldestBuffer; + + // Index of the next element to be popped. + Index mNextElementToPop{ 0 }; + + // Stats. + class AtomicCountAndWatermark + { + public: + explicit AtomicCountAndWatermark(int aCount) + : mCount(aCount) + , mWatermark(aCount) + { + } + + CountAndWatermark Get() const + { + return CountAndWatermark{ int(mCount), int(mWatermark) }; + } + + int operator++() + { + int count = int(++mCount); + // Update watermark. + for (;;) { + int watermark = int(mWatermark); + if (watermark >= count) { + // printf("++[%p] -=> %d-%d\n", this, count, watermark); + break; + } + if (mWatermark.compareExchange(watermark, count)) { + // printf("++[%p] -x> %d-(was %d now %d)\n", this, count, watermark, count); + break; + } + } + return count; + } + + int operator--() + { + int count = int(--mCount); + // printf("--[%p] -> %d\n", this, count); + return count; + } + + private: + Atomic mCount; + Atomic mWatermark; + }; + // All buffers in the mMostRecentBuffer deque. + AtomicCountAndWatermark mLiveBuffersStats; + // All buffers in the mReusableBuffers stack. + AtomicCountAndWatermark mReusableBuffersStats; + // All allocated buffers (sum of above). + AtomicCountAndWatermark mAllocatedBuffersStats; +}; + +} // namespace mozilla + +#endif // mozilla_MultiWriterQueue_h_ diff --git a/dom/media/doctor/gtest/TestMultiWriterQueue.cpp b/dom/media/doctor/gtest/TestMultiWriterQueue.cpp new file mode 100644 index 000000000000..ebd2f5da38d2 --- /dev/null +++ b/dom/media/doctor/gtest/TestMultiWriterQueue.cpp @@ -0,0 +1,400 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "MultiWriterQueue.h" + +#include "DDTimeStamp.h" +#include "mozilla/Assertions.h" +#include "nsDeque.h" +#include "nsThreadUtils.h" + +#include + +using mozilla::MultiWriterQueue; +using mozilla::MultiWriterQueueDefaultBufferSize; +using mozilla::MultiWriterQueueReaderLocking_Mutex; +using mozilla::MultiWriterQueueReaderLocking_None; + +template +static void +TestMultiWriterQueueST(const int loops) +{ + using Q = MultiWriterQueue; + Q q; + + int pushes = 0; + // Go through 2 cycles of pushes&pops, to exercize reusable buffers. + for (int max = loops; max <= loops * 2; max *= 2) { + // Push all numbers. + for (int i = 1; i <= max; ++i) { + bool newBuffer = q.Push(i); + // A new buffer should be added at the last push of each buffer. + EXPECT_EQ(++pushes % BufferSize == 0, newBuffer); + } + + // Pop numbers, should be FIFO. + int x = 0; + q.PopAll([&](int& i) { EXPECT_EQ(++x, i); }); + + // We should have got all numbers. + EXPECT_EQ(max, x); + + // Nothing left. + q.PopAll([&](int&) { EXPECT_TRUE(false); }); + } +} + +TEST(MultiWriterQueue, SingleThreaded) +{ + TestMultiWriterQueueST<1>(10); + TestMultiWriterQueueST<2>(10); + TestMultiWriterQueueST<4>(10); + + TestMultiWriterQueueST<10>(9); + TestMultiWriterQueueST<10>(10); + TestMultiWriterQueueST<10>(11); + TestMultiWriterQueueST<10>(19); + TestMultiWriterQueueST<10>(20); + TestMultiWriterQueueST<10>(21); + TestMultiWriterQueueST<10>(999); + TestMultiWriterQueueST<10>(1000); + TestMultiWriterQueueST<10>(1001); + + TestMultiWriterQueueST<8192>(8192 * 4 + 1); +} + +template +static void +TestMultiWriterQueueMT(int aWriterThreads, + int aReaderThreads, + int aTotalLoops, + const char* aPrintPrefix) +{ + Q q; + + const int threads = aWriterThreads + aReaderThreads; + const int loops = aTotalLoops / aWriterThreads; + + nsIThread** array = new nsIThread*[threads]; + + mozilla::Atomic pushThreadsCompleted{ 0 }; + int pops = 0; + + nsCOMPtr popper = NS_NewRunnableFunction("MWQPopper", [&]() { + // int popsBefore = pops; + // int allocsBefore = q.AllocatedBuffersStats().mCount; + q.PopAll([&pops](const int& i) { ++pops; }); + // if (pops != popsBefore || + // q.AllocatedBuffersStats().mCount != allocsBefore) { + // printf("%s threads=1+%d loops/thread=%d pops=%d " + // "buffers: live=%d (w %d) reusable=%d (w %d) " + // "alloc=%d (w %d)\n", + // aPrintPrefix, + // aWriterThreads, + // loops, + // pops, + // q.LiveBuffersStats().mCount, + // q.LiveBuffersStats().mWatermark, + // q.ReusableBuffersStats().mCount, + // q.ReusableBuffersStats().mWatermark, + // q.AllocatedBuffersStats().mCount, + // q.AllocatedBuffersStats().mWatermark); + // } + }); + // Cycle through reader threads. + mozilla::Atomic readerThread{ 0 }; + + double start = mozilla::ToSeconds(mozilla::DDNow()); + + for (int k = 0; k < threads; k++) { + // First `aReaderThreads` threads to pop, all others to push. + if (k < aReaderThreads) { + nsCOMPtr t; + nsresult rv = NS_NewNamedThread("MWQThread", getter_AddRefs(t)); + EXPECT_TRUE(NS_SUCCEEDED(rv)); + NS_ADDREF(array[k] = t); + } else { + nsCOMPtr t; + nsCOMPtr r = NS_NewRunnableFunction("MWQPusher", [&, k]() { + // Give a bit of breathing space to construct other threads. + PR_Sleep(PR_MillisecondsToInterval(100)); + + for (int i = 0; i < loops; ++i) { + if (q.Push(k * threads + i) && aReaderThreads != 0) { + // Run a popper task every time we push the last element of a + // buffer. + array[++readerThread % aReaderThreads]->Dispatch( + popper, nsIThread::DISPATCH_NORMAL); + } + } + ++pushThreadsCompleted; + }); + nsresult rv = NS_NewNamedThread("MWQThread", getter_AddRefs(t), r); + EXPECT_TRUE(NS_SUCCEEDED(rv)); + NS_ADDREF(array[k] = t); + } + } + + for (int k = threads - 1; k >= 0; k--) { + array[k]->Shutdown(); + NS_RELEASE(array[k]); + } + delete[] array; + + // There may be a few more elements that haven't been read yet. + q.PopAll([&pops](const int& i) { ++pops; }); + const int pushes = aWriterThreads * loops; + EXPECT_EQ(pushes, pops); + q.PopAll([&pops](const int& i) { EXPECT_TRUE(false); }); + + double duration = mozilla::ToSeconds(mozilla::DDNow()) - start - 0.1; + printf("%s threads=%dw+%dr loops/thread=%d pushes=pops=%d duration=%fs " + "pushes/s=%f buffers: live=%d (w %d) reusable=%d (w %d) " + "alloc=%d (w %d)\n", + aPrintPrefix, + aWriterThreads, + aReaderThreads, + loops, + pushes, + duration, + pushes / duration, + q.LiveBuffersStats().mCount, + q.LiveBuffersStats().mWatermark, + q.ReusableBuffersStats().mCount, + q.ReusableBuffersStats().mWatermark, + q.AllocatedBuffersStats().mCount, + q.AllocatedBuffersStats().mWatermark); +} + +TEST(MultiWriterQueue, MultiWriterSingleReader) +{ + // Small BufferSize, to exercize the buffer management code. + TestMultiWriterQueueMT< + MultiWriterQueue>( + 1, 0, 2 * 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 1, 1, 2 * 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 2, 1, 2 * 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 3, 1, 2 * 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 4, 1, 2 * 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 5, 1, 2 * 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 6, 1, 2 * 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 7, 1, 2 * 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 8, 1, 2 * 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 9, 1, 2 * 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 10, 1, 2 * 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 16, 1, 2 * 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 32, 1, 2 * 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 64, 1, 2 * 1024 * 1024, "MultiWriterQueue"); + + // A more real-life buffer size. + TestMultiWriterQueueMT>( + 64, + 1, + 2 * 1024 * 1024, + "MultiWriterQueue"); + + // DEBUG-mode thread-safety checks should make the following (multi-reader + // with no locking) crash; uncomment to verify. + // TestMultiWriterQueueMT< + // MultiWriterQueue>(64, 2, 2*1024*1024); +} + +TEST(MultiWriterQueue, MultiWriterMultiReader) +{ + static_assert( + mozilla::IsSame< + MultiWriterQueue, + MultiWriterQueue>::value, + "MultiWriterQueue reader locking should use Mutex by default"); + + // Small BufferSize, to exercize the buffer management code. + TestMultiWriterQueueMT< + MultiWriterQueue>( + 1, 2, 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 2, 2, 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 3, 2, 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 4, 2, 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 5, 2, 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 6, 2, 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 7, 2, 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 8, 2, 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 9, 2, 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 10, 4, 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 16, 8, 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 32, 16, 1024 * 1024, "MultiWriterQueue"); + TestMultiWriterQueueMT< + MultiWriterQueue>( + 64, 32, 1024 * 1024, "MultiWriterQueue"); + + // A more real-life buffer size. + TestMultiWriterQueueMT>( + 64, + 32, + 1024 * 1024, + "MultiWriterQueue"); +} + +// Single-threaded use only. +struct DequeWrapperST +{ + nsDeque mDQ; + + bool Push(int i) + { + mDQ.PushFront(reinterpret_cast(static_cast(i))); + return true; + } + template + void PopAll(F&& aF) + { + while (mDQ.GetSize() != 0) { + int i = static_cast(reinterpret_cast(mDQ.Pop())); + aF(i); + } + } + + struct CountAndWatermark + { + int mCount = 0; + int mWatermark = 0; + } mLiveBuffersStats, mReusableBuffersStats, mAllocatedBuffersStats; + + CountAndWatermark LiveBuffersStats() const { return mLiveBuffersStats; } + CountAndWatermark ReusableBuffersStats() const + { + return mReusableBuffersStats; + } + CountAndWatermark AllocatedBuffersStats() const + { + return mAllocatedBuffersStats; + } +}; + +// Multi-thread (atomic) writes allowed, make sure you don't pop unless writes can't happen. +struct DequeWrapperAW : DequeWrapperST +{ + mozilla::Atomic mWriting{ false }; + + bool Push(int i) + { + while (!mWriting.compareExchange(false, true)) { + } + mDQ.PushFront(reinterpret_cast(static_cast(i))); + mWriting = false; + return true; + } +}; + +// Multi-thread writes allowed, make sure you don't pop unless writes can't happen. +struct DequeWrapperMW : DequeWrapperST +{ + mozilla::Mutex mMutex; + + DequeWrapperMW() + : mMutex("DequeWrapperMW/MT") + { + } + + bool Push(int i) + { + mozilla::MutexAutoLock lock(mMutex); + mDQ.PushFront(reinterpret_cast(static_cast(i))); + return true; + } +}; + +// Multi-thread read&writes allowed. +struct DequeWrapperMT : DequeWrapperMW +{ + template + void PopAll(F&& aF) + { + while (mDQ.GetSize() != 0) { + int i; + { + mozilla::MutexAutoLock lock(mMutex); + i = static_cast(reinterpret_cast(mDQ.Pop())); + } + aF(i); + } + } +}; + +TEST(MultiWriterQueue, nsDequeBenchmark) +{ + TestMultiWriterQueueMT( + 1, 0, 2 * 1024 * 1024, "DequeWrapperST "); + + TestMultiWriterQueueMT( + 1, 0, 2 * 1024 * 1024, "DequeWrapperAW "); + TestMultiWriterQueueMT( + 1, 0, 2 * 1024 * 1024, "DequeWrapperMW "); + TestMultiWriterQueueMT( + 1, 0, 2 * 1024 * 1024, "DequeWrapperMT "); + TestMultiWriterQueueMT( + 1, 1, 2 * 1024 * 1024, "DequeWrapperMT "); + + TestMultiWriterQueueMT( + 8, 0, 2 * 1024 * 1024, "DequeWrapperAW "); + TestMultiWriterQueueMT( + 8, 0, 2 * 1024 * 1024, "DequeWrapperMW "); + TestMultiWriterQueueMT( + 8, 0, 2 * 1024 * 1024, "DequeWrapperMT "); + TestMultiWriterQueueMT( + 8, 1, 2 * 1024 * 1024, "DequeWrapperMT "); +} \ No newline at end of file diff --git a/dom/media/doctor/gtest/moz.build b/dom/media/doctor/gtest/moz.build index 17a5f37bdedb..e640fc847574 100644 --- a/dom/media/doctor/gtest/moz.build +++ b/dom/media/doctor/gtest/moz.build @@ -5,6 +5,7 @@ # file, You can obtain one at http://mozilla.org/MPL/2.0/. UNIFIED_SOURCES += [ + 'TestMultiWriterQueue.cpp', 'TestRollingNumber.cpp', ] From 53d5092208adbec12032c1f5441b83f269700ec2 Mon Sep 17 00:00:00 2001 From: Gerald Squelart Date: Mon, 28 Aug 2017 11:54:12 +1200 Subject: [PATCH 11/15] Bug 1394995 - Initial implementation of DecoderDoctorLogger - r=jwwang DecoderDoctorLogger and its related classes offer a cheap way to gather log messages from media stack objects, and then process these messages to extract object lifetimes and messages related to separate HTMLMediaElement's. MozReview-Commit-ID: AIf2nAMjoDy --HG-- extra : rebase_source : cf10185538aded870b9005e88563751f3638ae65 --- dom/media/doctor/DDLifetime.cpp | 37 ++ dom/media/doctor/DDLifetime.h | 78 +++ dom/media/doctor/DDLifetimes.cpp | 101 ++++ dom/media/doctor/DDLifetimes.h | 142 +++++ dom/media/doctor/DDLogClass.cpp | 22 + dom/media/doctor/DDLogClass.h | 51 ++ dom/media/doctor/DDLogMessage.cpp | 50 ++ dom/media/doctor/DDLogMessage.h | 46 ++ dom/media/doctor/DDLogObject.cpp | 26 + dom/media/doctor/DDLogObject.h | 72 +++ dom/media/doctor/DDLogUtils.cpp | 11 + dom/media/doctor/DDLogUtils.h | 33 ++ dom/media/doctor/DDLogValue.cpp | 146 +++++ dom/media/doctor/DDLogValue.h | 65 ++ dom/media/doctor/DDLoggedTypeTraits.h | 110 ++++ dom/media/doctor/DDMediaLog.cpp | 29 + dom/media/doctor/DDMediaLog.h | 43 ++ dom/media/doctor/DDMediaLogs.cpp | 722 +++++++++++++++++++++++ dom/media/doctor/DDMediaLogs.h | 207 +++++++ dom/media/doctor/DDMessageIndex.h | 26 + dom/media/doctor/DDTimeStamp.cpp | 22 + dom/media/doctor/DDTimeStamp.h | 29 + dom/media/doctor/DecoderDoctorLogger.cpp | 171 ++++++ dom/media/doctor/DecoderDoctorLogger.h | 461 +++++++++++++++ dom/media/doctor/moz.build | 16 + 25 files changed, 2716 insertions(+) create mode 100644 dom/media/doctor/DDLifetime.cpp create mode 100644 dom/media/doctor/DDLifetime.h create mode 100644 dom/media/doctor/DDLifetimes.cpp create mode 100644 dom/media/doctor/DDLifetimes.h create mode 100644 dom/media/doctor/DDLogClass.cpp create mode 100644 dom/media/doctor/DDLogClass.h create mode 100644 dom/media/doctor/DDLogMessage.cpp create mode 100644 dom/media/doctor/DDLogMessage.h create mode 100644 dom/media/doctor/DDLogObject.cpp create mode 100644 dom/media/doctor/DDLogObject.h create mode 100644 dom/media/doctor/DDLogUtils.cpp create mode 100644 dom/media/doctor/DDLogUtils.h create mode 100644 dom/media/doctor/DDLogValue.cpp create mode 100644 dom/media/doctor/DDLogValue.h create mode 100644 dom/media/doctor/DDLoggedTypeTraits.h create mode 100644 dom/media/doctor/DDMediaLog.cpp create mode 100644 dom/media/doctor/DDMediaLog.h create mode 100644 dom/media/doctor/DDMediaLogs.cpp create mode 100644 dom/media/doctor/DDMediaLogs.h create mode 100644 dom/media/doctor/DDMessageIndex.h create mode 100644 dom/media/doctor/DDTimeStamp.cpp create mode 100644 dom/media/doctor/DDTimeStamp.h create mode 100644 dom/media/doctor/DecoderDoctorLogger.cpp create mode 100644 dom/media/doctor/DecoderDoctorLogger.h diff --git a/dom/media/doctor/DDLifetime.cpp b/dom/media/doctor/DDLifetime.cpp new file mode 100644 index 000000000000..b884776259b9 --- /dev/null +++ b/dom/media/doctor/DDLifetime.cpp @@ -0,0 +1,37 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "DDLifetime.h" + +namespace mozilla { + +void +DDLifetime::AppendPrintf(nsCString& aString) const +{ + if (!mDerivedObject.Pointer()) { + mObject.AppendPrintf(aString); + aString.AppendPrintf("#%" PRIi32, mTag); + } else { + mDerivedObject.AppendPrintf(aString); + aString.AppendPrintf("#%" PRIi32 " (as ", mTag); + if (mObject.Pointer() == mDerivedObject.Pointer()) { + aString.Append(mObject.TypeName()); + } else { + mObject.AppendPrintf(aString); + } + aString.Append(")"); + } +} + +nsCString +DDLifetime::Printf() const +{ + nsCString s; + AppendPrintf(s); + return s; +} + +} // namespace mozilla diff --git a/dom/media/doctor/DDLifetime.h b/dom/media/doctor/DDLifetime.h new file mode 100644 index 000000000000..14435cd6402d --- /dev/null +++ b/dom/media/doctor/DDLifetime.h @@ -0,0 +1,78 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef DDLifetime_h_ +#define DDLifetime_h_ + +#include "DDLogObject.h" +#include "DDMessageIndex.h" +#include "DDTimeStamp.h" + +namespace mozilla { + +namespace dom { +class HTMLMediaElement; +} // namespace dom + +// This struct records the lifetime of one C++ object. +// Note that multiple objects may have the same address and type (at different +// times), so the recorded construction/destruction times should be used to +// distinguish them. +struct DDLifetime +{ + const DDLogObject mObject; + const DDMessageIndex mConstructionIndex; + const DDTimeStamp mConstructionTimeStamp; + // Only valid when mDestructionTimeStamp is not null. + DDMessageIndex mDestructionIndex; + DDTimeStamp mDestructionTimeStamp; + // Associated HTMLMediaElement, initially nullptr until this object can be + // linked to its HTMLMediaElement. + const dom::HTMLMediaElement* mMediaElement; + // If not null, derived object for which this DDLifetime is a base class. + // This is used to link messages from the same object, even when they + // originate from a method on a base class. + // Note: We assume a single-inheritance hierarchy. + DDLogObject mDerivedObject; + DDMessageIndex mDerivedObjectLinkingIndex; + // Unique tag used to identify objects in a log, easier to read than object + // pointers. + // Negative and unique for unassociated objects. + // Positive for associated objects, and unique for that HTMLMediaElement + // group. + int32_t mTag; + + DDLifetime(DDLogObject aObject, + DDMessageIndex aConstructionIndex, + DDTimeStamp aConstructionTimeStamp, + int32_t aTag) + : mObject(aObject) + , mConstructionIndex(aConstructionIndex) + , mConstructionTimeStamp(aConstructionTimeStamp) + , mDestructionIndex(0) + , mMediaElement(nullptr) + , mDerivedObjectLinkingIndex(0) + , mTag(aTag) + { + } + + // Is this lifetime alive at the given index? + // I.e.: Constructed before, and destroyed later or not yet. + bool IsAliveAt(DDMessageIndex aIndex) const + { + return aIndex >= mConstructionIndex && + (!mDestructionTimeStamp || aIndex <= mDestructionIndex); + } + + // Print the object's pointer, tag and class name (and derived class). E.g.: + // "dom::HTMLVideoElement[134073800]#1 (as dom::HTMLMediaElement)" + void AppendPrintf(nsCString& aString) const; + nsCString Printf() const; +}; + +} // namespace mozilla + +#endif // DDLifetime_h_ diff --git a/dom/media/doctor/DDLifetimes.cpp b/dom/media/doctor/DDLifetimes.cpp new file mode 100644 index 000000000000..450c54b8c144 --- /dev/null +++ b/dom/media/doctor/DDLifetimes.cpp @@ -0,0 +1,101 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "DDLifetimes.h" + +#include "DDLogUtils.h" + +namespace mozilla { + +DDLifetime* +DDLifetimes::FindLifetime(const DDLogObject& aObject, + const DDMessageIndex& aIndex) +{ + LifetimesForObject* lifetimes = mLifetimes.Get(aObject); + if (lifetimes) { + for (DDLifetime& lifetime : *lifetimes) { + if (lifetime.mObject == aObject && lifetime.IsAliveAt(aIndex)) { + return &lifetime; + } + } + } + return nullptr; +} + +const DDLifetime* +DDLifetimes::FindLifetime(const DDLogObject& aObject, + const DDMessageIndex& aIndex) const +{ + const LifetimesForObject* lifetimes = mLifetimes.Get(aObject); + if (lifetimes) { + for (const DDLifetime& lifetime : *lifetimes) { + if (lifetime.mObject == aObject && lifetime.IsAliveAt(aIndex)) { + return &lifetime; + } + } + } + return nullptr; +} + +DDLifetime& +DDLifetimes::CreateLifetime(const DDLogObject& aObject, + DDMessageIndex aIndex, + const DDTimeStamp& aConstructionTimeStamp) +{ + // Use negative tags for yet-unclassified messages. + static int32_t sTag = 0; + if (--sTag > 0) { + sTag = -1; + } + LifetimesForObject* lifetimes = mLifetimes.LookupOrAdd(aObject, 1); + DDLifetime& lifetime = *lifetimes->AppendElement( + DDLifetime(aObject, aIndex, aConstructionTimeStamp, sTag)); + return lifetime; +} + +void +DDLifetimes::RemoveLifetime(const DDLifetime* aLifetime) +{ + LifetimesForObject* lifetimes = mLifetimes.Get(aLifetime->mObject); + MOZ_ASSERT(lifetimes); + DDL_LOG(aLifetime->mMediaElement ? mozilla::LogLevel::Debug + : mozilla::LogLevel::Warning, + "Remove lifetime %s", + aLifetime->Printf().get()); + // We should have been given a pointer inside this lifetimes array. + auto arrayIndex = aLifetime - lifetimes->Elements(); + MOZ_ASSERT(static_cast(arrayIndex) < lifetimes->Length()); + lifetimes->RemoveElementAt(arrayIndex); +} + +void +DDLifetimes::RemoveLifetimesFor(const dom::HTMLMediaElement* aMediaElement) +{ + for (auto iter = mLifetimes.Iter(); !iter.Done(); iter.Next()) { + iter.UserData()->RemoveElementsBy( + [aMediaElement](const DDLifetime& lifetime) { + return lifetime.mMediaElement == aMediaElement; + }); + } +} + +void +DDLifetimes::Clear() +{ + mLifetimes.Clear(); +} + +size_t +DDLifetimes::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const +{ + size_t size = mLifetimes.ShallowSizeOfExcludingThis(aMallocSizeOf); + for (auto iter = mLifetimes.ConstIter(); !iter.Done(); iter.Next()) { + size += iter.UserData()->ShallowSizeOfExcludingThis(aMallocSizeOf); + } + return size; +} + +} // namespace mozilla diff --git a/dom/media/doctor/DDLifetimes.h b/dom/media/doctor/DDLifetimes.h new file mode 100644 index 000000000000..a3f96865f613 --- /dev/null +++ b/dom/media/doctor/DDLifetimes.h @@ -0,0 +1,142 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef DDLifetimes_h_ +#define DDLifetimes_h_ + +#include "DDLifetime.h" +#include "DDLoggedTypeTraits.h" +#include "nsClassHashtable.h" +#include "nsTArray.h" + +namespace mozilla { + +// Managed list of lifetimes. +class DDLifetimes +{ +public: + // DDLifetime for a given aObject, that exists at the aIndex time; + // otherwise nullptr. + DDLifetime* FindLifetime(const DDLogObject& aObject, + const DDMessageIndex& aIndex); + + // DDLifetime for a given aObject, that exists at the aIndex time; + // otherwise nullptr. + const DDLifetime* FindLifetime(const DDLogObject& aObject, + const DDMessageIndex& aIndex) const; + + // Create a lifetime with the given object and construction index&time. + DDLifetime& CreateLifetime(const DDLogObject& aObject, + DDMessageIndex aIndex, + const DDTimeStamp& aConstructionTimeStamp); + + // Remove an existing lifetime (assumed to just have been found by + // FindLifetime()). + void RemoveLifetime(const DDLifetime* aLifetime); + + // Remove all lifetimes associated with the given HTMLMediaElement. + void RemoveLifetimesFor(const dom::HTMLMediaElement* aMediaElement); + + // Remove all lifetimes. + void Clear(); + + // Visit all lifetimes associated with an HTMLMediaElement and run + // `aF(const DDLifetime&)` on each one. + // If aOnlyHTMLMediaElement is true, only run aF once of that element. + template + void Visit(const dom::HTMLMediaElement* aMediaElement, + F&& aF, + bool aOnlyHTMLMediaElement = false) const + { + for (auto iter = mLifetimes.ConstIter(); !iter.Done(); iter.Next()) { + for (const DDLifetime& lifetime : *iter.UserData()) { + if (lifetime.mMediaElement == aMediaElement) { + if (aOnlyHTMLMediaElement) { + if (lifetime.mObject.Pointer() == aMediaElement && + lifetime.mObject.TypeName() == + DDLoggedTypeTraits::Name()) { + aF(lifetime); + break; + } + continue; + } + static_assert(IsSame::value, ""); + aF(lifetime); + } + } + } + } + + // Visit all lifetimes associated with an HTMLMediaElement and run + // `aF(const DDLifetime&)` on each one. + // If aF() returns false, the loop continues. + // If aF() returns true, the loop stops, and true is returned immediately. + // If all aF() calls have returned false, false is returned at the end. + template + bool VisitBreakable(const dom::HTMLMediaElement* aMediaElement, F&& aF) const + { + for (auto iter = mLifetimes.ConstIter(); !iter.Done(); iter.Next()) { + for (const DDLifetime& lifetime : *iter.UserData()) { + if (lifetime.mMediaElement == aMediaElement) { + static_assert(IsSame::value, ""); + if (aF(lifetime)) { + return true; + } + } + } + } + return false; + } + + size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const; + +private: + // Hashtable key to use for each DDLogObject. + class DDLogObjectHashKey : public PLDHashEntryHdr + { + public: + typedef const DDLogObject& KeyType; + typedef const DDLogObject* KeyTypePointer; + + explicit DDLogObjectHashKey(KeyTypePointer aKey) + : mValue(*aKey) + { + } + DDLogObjectHashKey(const DDLogObjectHashKey& aToCopy) + : mValue(aToCopy.mValue) + { + } + ~DDLogObjectHashKey() {} + + 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 HashBytes(aKey, sizeof(DDLogObject)); + } + enum + { + ALLOW_MEMMOVE = true + }; + + private: + const DDLogObject mValue; + }; + + // Array of all DDLifetimes for a given DDLogObject; they should be + // distinguished by their construction&destruction times. + using LifetimesForObject = nsTArray; + + // For each DDLogObject, we store an array of all objects that have used this + // pointer and type. + nsClassHashtable mLifetimes; +}; + +} // namespace mozilla + +#endif // DDLifetimes_h_ diff --git a/dom/media/doctor/DDLogClass.cpp b/dom/media/doctor/DDLogClass.cpp new file mode 100644 index 000000000000..346ca53b16e8 --- /dev/null +++ b/dom/media/doctor/DDLogClass.cpp @@ -0,0 +1,22 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "DDLogClass.h" + +namespace mozilla { + +const char* const kDDLogClassShortStrings[kDDLogClassCount] = { + "con", "dcn", "des", "lnk", "ulk", "prp", "evt", "api", "log" +}; +const char* const kDDLogClassLongStrings[kDDLogClassCount] = { + "Construction", "Derived Construction", + "Destruction", "Link", + "Unlink", "Property", + "Event", "API", + "Log" +}; + +} // namespace mozilla diff --git a/dom/media/doctor/DDLogClass.h b/dom/media/doctor/DDLogClass.h new file mode 100644 index 000000000000..d2c9618dd071 --- /dev/null +++ b/dom/media/doctor/DDLogClass.h @@ -0,0 +1,51 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef DDLogClass_h_ +#define DDLogClass_h_ + +#include "mozilla/Assertions.h" +#include "mozilla/DefineEnum.h" + +namespace mozilla { + +// Enum used to classify log messages. +// Those starting with '_' are for internal use only. +MOZ_DEFINE_ENUM_CLASS(DDLogClass, + (_Construction, + _DerivedConstruction, + _Destruction, + _Link, + _Unlink, + Property, + Event, + API, + Log)); + +// Corresponding short strings, used as JSON property names when logs are +// retrieved. +extern const char* const kDDLogClassShortStrings[kDDLogClassCount]; + +inline const char* +ToShortString(DDLogClass aClass) +{ + MOZ_ASSERT(static_cast(aClass) < kDDLogClassCount); + return kDDLogClassShortStrings[static_cast(aClass)]; +} + +// Corresponding long strings, for use in descriptive UI. +extern const char* const kDDLogClassLongStrings[kDDLogClassCount]; + +inline const char* +ToLongString(DDLogClass aClass) +{ + MOZ_ASSERT(static_cast(aClass) < kDDLogClassCount); + return kDDLogClassLongStrings[static_cast(aClass)]; +} + +} // namespace mozilla + +#endif // DDLogClass_h_ diff --git a/dom/media/doctor/DDLogMessage.cpp b/dom/media/doctor/DDLogMessage.cpp new file mode 100644 index 000000000000..4efd5b6fd3f0 --- /dev/null +++ b/dom/media/doctor/DDLogMessage.cpp @@ -0,0 +1,50 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "DDLogMessage.h" + +#include "DDLifetimes.h" + +namespace mozilla { + +nsCString +DDLogMessage::Print() const +{ + nsCString str; + str.AppendPrintf("%" PRImi " | %f | %s[%p] | %s | %s | ", + mIndex.Value(), + ToSeconds(mTimeStamp), + mObject.TypeName(), + mObject.Pointer(), + ToShortString(mClass), + mLabel); + AppendToString(mValue, str); + return str; +} + +nsCString +DDLogMessage::Print(const DDLifetimes& aLifetimes) const +{ + nsCString str; + const DDLifetime* lifetime = aLifetimes.FindLifetime(mObject, mIndex); + str.AppendPrintf("%" PRImi " | %f | ", mIndex.Value(), ToSeconds(mTimeStamp)); + lifetime->AppendPrintf(str); + str.AppendPrintf(" | %s | %s | ", ToShortString(mClass), mLabel); + if (!mValue.is()) { + AppendToString(mValue, str); + } else { + const DDLifetime* lifetime2 = + aLifetimes.FindLifetime(mValue.as(), mIndex); + if (lifetime2) { + lifetime2->AppendPrintf(str); + } else { + AppendToString(mValue, str); + } + } + return str; +} + +} // namespace mozilla diff --git a/dom/media/doctor/DDLogMessage.h b/dom/media/doctor/DDLogMessage.h new file mode 100644 index 000000000000..c4c498b2fa3d --- /dev/null +++ b/dom/media/doctor/DDLogMessage.h @@ -0,0 +1,46 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef DDLogMessage_h_ +#define DDLogMessage_h_ + +#include "DDLogClass.h" +#include "DDLogObject.h" +#include "DDLogValue.h" +#include "DDMessageIndex.h" +#include "DDTimeStamp.h" +#include "mozilla/Atomics.h" +#include "nsString.h" + +namespace mozilla { + +class DDLifetimes; + +// Structure containing all the information needed in each log message +// (before and after processing). +struct DDLogMessage +{ + DDMessageIndex mIndex; + DDTimeStamp mTimeStamp; + DDLogObject mObject; + DDLogClass mClass; + const char* mLabel; + DDLogValue mValue = DDLogValue{ DDNoValue{} }; + + // Print the message. Format: + // "index | timestamp | object | message-class | label | value". E.g.: + // "29 | 5.047547 | dom::HTMLMediaElement[134073800] | lnk | decoder | MediaDecoder[136078200]" + nsCString Print() const; + + // Print the message, using object information from aLifetimes. Format: + // "index | timestamp | object | message-class | label | value". E.g.: + // "29 | 5.047547 | dom::HTMLVideoElement[134073800]#1 (as dom::HTMLMediaElement) | lnk | decoder | MediaSourceDecoder[136078200]#5 (as MediaDecoder)" + nsCString Print(const DDLifetimes& aLifetimes) const; +}; + +} // namespace mozilla + +#endif // DDLogMessage_h_ diff --git a/dom/media/doctor/DDLogObject.cpp b/dom/media/doctor/DDLogObject.cpp new file mode 100644 index 000000000000..b48159568392 --- /dev/null +++ b/dom/media/doctor/DDLogObject.cpp @@ -0,0 +1,26 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "DDLogObject.h" + +namespace mozilla { + +void +DDLogObject::AppendPrintf(nsCString& mString) const +{ + MOZ_ASSERT(mTypeName); + mString.AppendPrintf("%s[%p]", mTypeName, mPointer); +} + +nsCString +DDLogObject::Printf() const +{ + nsCString s; + AppendPrintf(s); + return s; +} + +} // namespace mozilla diff --git a/dom/media/doctor/DDLogObject.h b/dom/media/doctor/DDLogObject.h new file mode 100644 index 000000000000..6b13e93d4834 --- /dev/null +++ b/dom/media/doctor/DDLogObject.h @@ -0,0 +1,72 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef DDLogObject_h_ +#define DDLogObject_h_ + +#include "nsString.h" + +namespace mozilla { + +// DDLogObject identifies a C++ object by its pointer and its class name (as +// provided in a DDLoggedTypeTrait.) +// Note that a DDLogObject could have the exact same pointer&type as a previous +// one, so extra information is needed to distinguish them, see DDLifetime. +class DDLogObject +{ +public: + // Default-initialization with null pointer. + DDLogObject() + : mTypeName("") + , mPointer(nullptr) + { + } + + // Construction with given non-null type name and pointer. + DDLogObject(const char* aTypeName, const void* aPointer) + : mTypeName(aTypeName) + , mPointer(aPointer) + { + MOZ_ASSERT(aTypeName); + MOZ_ASSERT(aPointer); + } + + // Sets this DDLogObject to an actual object. + void Set(const char* aTypeName, const void* aPointer) + { + MOZ_ASSERT(aTypeName); + MOZ_ASSERT(aPointer); + mTypeName = aTypeName; + mPointer = aPointer; + } + + // Object pointer, used for identification purposes only. + const void* Pointer() const { return mPointer; } + + // Type name. Should only be accessed after non-null pointer initialization. + const char* TypeName() const + { + MOZ_ASSERT(mPointer); + return mTypeName; + } + + bool operator==(const DDLogObject& a) const + { + return mPointer == a.mPointer && (!mPointer || mTypeName == a.mTypeName); + } + + // Print the type name and pointer, e.g.: "MediaDecoder[136078200]". + void AppendPrintf(nsCString& mString) const; + nsCString Printf() const; + +private: + const char* mTypeName; + const void* mPointer; +}; + +} // namespace mozilla + +#endif // DDLogObject_h_ diff --git a/dom/media/doctor/DDLogUtils.cpp b/dom/media/doctor/DDLogUtils.cpp new file mode 100644 index 000000000000..50f0b676d03a --- /dev/null +++ b/dom/media/doctor/DDLogUtils.cpp @@ -0,0 +1,11 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "DDLogUtils.h" + +mozilla::LazyLogModule sDecoderDoctorLoggerLog("DDLogger"); + +mozilla::LazyLogModule sDecoderDoctorLoggerEndLog("DDLoggerEnd"); diff --git a/dom/media/doctor/DDLogUtils.h b/dom/media/doctor/DDLogUtils.h new file mode 100644 index 000000000000..6074d2f4670a --- /dev/null +++ b/dom/media/doctor/DDLogUtils.h @@ -0,0 +1,33 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef DDLogUtils_h_ +#define DDLogUtils_h_ + +#include "mozilla/Logging.h" + +// Logging for the DecoderDoctorLoggger code. +extern mozilla::LazyLogModule sDecoderDoctorLoggerLog; +#define DDL_LOG(level, arg, ...) \ + MOZ_LOG(sDecoderDoctorLoggerLog, level, (arg, ##__VA_ARGS__)) +#define DDL_DEBUG(arg, ...) \ + DDL_LOG(mozilla::LogLevel::Debug, arg, ##__VA_ARGS__) +#define DDL_INFO(arg, ...) DDL_LOG(mozilla::LogLevel::Info, arg, ##__VA_ARGS__) +#define DDL_WARN(arg, ...) \ + DDL_LOG(mozilla::LogLevel::Warning, arg, ##__VA_ARGS__) + +// Output at shutdown the log given to DecoderDoctorLogger. +extern mozilla::LazyLogModule sDecoderDoctorLoggerEndLog; +#define DDLE_LOG(level, arg, ...) \ + MOZ_LOG(sDecoderDoctorLoggerEndLog, level, (arg, ##__VA_ARGS__)) +#define DDLE_DEBUG(arg, ...) \ + DDLE_LOG(mozilla::LogLevel::Debug, arg, ##__VA_ARGS__) +#define DDLE_INFO(arg, ...) \ + DDLE_LOG(mozilla::LogLevel::Info, arg, ##__VA_ARGS__) +#define DDLE_WARN(arg, ...) \ + DDLE_LOG(mozilla::LogLevel::Warning, arg, ##__VA_ARGS__) + +#endif // DDLogUtils_h_ diff --git a/dom/media/doctor/DDLogValue.cpp b/dom/media/doctor/DDLogValue.cpp new file mode 100644 index 000000000000..bdc732b53ffd --- /dev/null +++ b/dom/media/doctor/DDLogValue.cpp @@ -0,0 +1,146 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "DDLogValue.h" + +#include "mozilla/JSONWriter.h" + +namespace mozilla { + +struct LogValueMatcher +{ + nsCString& mString; + + void match(const DDNoValue&) const {} + void match(const DDLogObject& a) const { a.AppendPrintf(mString); } + void match(const char* a) const { mString.AppendPrintf(R"("%s")", a); } + void match(const nsCString& a) const + { + mString.AppendPrintf(R"(nsCString("%s"))", a.Data()); + } + void match(bool a) const { mString.AppendPrintf(a ? "true" : "false"); } + void match(int8_t a) const { mString.AppendPrintf("int8_t(%" PRIi8 ")", a); } + void match(uint8_t a) const + { + mString.AppendPrintf("uint8_t(%" PRIu8 ")", a); + } + void match(int16_t a) const + { + mString.AppendPrintf("int16_t(%" PRIi16 ")", a); + } + void match(uint16_t a) const + { + mString.AppendPrintf("uint16_t(%" PRIu16 ")", a); + } + void match(int32_t a) const + { + mString.AppendPrintf("int32_t(%" PRIi32 ")", a); + } + void match(uint32_t a) const + { + mString.AppendPrintf("uint32_t(%" PRIu32 ")", a); + } + void match(int64_t a) const + { + mString.AppendPrintf("int64_t(%" PRIi64 ")", a); + } + void match(uint64_t a) const + { + mString.AppendPrintf("uint64_t(%" PRIu64 ")", a); + } + void match(double a) const { mString.AppendPrintf("double(%f)", a); } + void match(const DDRange& a) const + { + mString.AppendPrintf("%" PRIi64 "<=(%" PRIi64 "B)<%" PRIi64 "", + a.mOffset, + a.mBytes, + a.mOffset + a.mBytes); + } + void match(const nsresult& a) const + { + nsCString name; + GetErrorName(a, name); + mString.AppendPrintf( + "nsresult(%s =0x%08" PRIx32 ")", name.get(), static_cast(a)); + } + void match(const MediaResult& a) const + { + nsCString name; + GetErrorName(a.Code(), name); + mString.AppendPrintf("MediaResult(%s =0x%08" PRIx32 ", \"%s\")", + name.get(), + static_cast(a.Code()), + a.Message().get()); + } +}; + +void +AppendToString(const DDLogValue& aValue, nsCString& aString) +{ + aValue.match(LogValueMatcher{ aString }); +} + +struct LogValueMatcherJson +{ + JSONWriter& mJW; + const char* mPropertyName; + + void match(const DDNoValue&) const { mJW.NullProperty(mPropertyName); } + void match(const DDLogObject& a) const + { + mJW.StringProperty( + mPropertyName, + nsPrintfCString(R"("%s[%p]")", a.TypeName(), a.Pointer()).get()); + } + void match(const char* a) const { mJW.StringProperty(mPropertyName, a); } + void match(const nsCString& a) const + { + mJW.StringProperty(mPropertyName, a.Data()); + } + void match(bool a) const { mJW.BoolProperty(mPropertyName, a); } + void match(int8_t a) const { mJW.IntProperty(mPropertyName, a); } + void match(uint8_t a) const { mJW.IntProperty(mPropertyName, a); } + void match(int16_t a) const { mJW.IntProperty(mPropertyName, a); } + void match(uint16_t a) const { mJW.IntProperty(mPropertyName, a); } + void match(int32_t a) const { mJW.IntProperty(mPropertyName, a); } + void match(uint32_t a) const { mJW.IntProperty(mPropertyName, a); } + void match(int64_t a) const { mJW.IntProperty(mPropertyName, a); } + void match(uint64_t a) const { mJW.DoubleProperty(mPropertyName, a); } + void match(double a) const { mJW.DoubleProperty(mPropertyName, a); } + void match(const DDRange& a) const + { + mJW.StartArrayProperty(mPropertyName); + mJW.IntElement(a.mOffset); + mJW.IntElement(a.mOffset + a.mBytes); + mJW.EndArray(); + } + void match(const nsresult& a) const + { + nsCString name; + GetErrorName(a, name); + mJW.StringProperty(mPropertyName, name.get()); + } + void match(const MediaResult& a) const + { + nsCString name; + GetErrorName(a.Code(), name); + mJW.StringProperty(mPropertyName, + nsPrintfCString(R"lit("MediaResult(%s, %s)")lit", + name.get(), + a.Message().get()) + .get()); + } +}; + +void +ToJSON(const DDLogValue& aValue, + JSONWriter& aJSONWriter, + const char* aPropertyName) +{ + aValue.match(LogValueMatcherJson{ aJSONWriter, aPropertyName }); +} + +} // namespace mozilla diff --git a/dom/media/doctor/DDLogValue.h b/dom/media/doctor/DDLogValue.h new file mode 100644 index 000000000000..4ee840fcf758 --- /dev/null +++ b/dom/media/doctor/DDLogValue.h @@ -0,0 +1,65 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef DDLogValue_h_ +#define DDLogValue_h_ + +#include "DDLogObject.h" +#include "MediaResult.h" +#include "mozilla/Variant.h" +#include "nsString.h" + +namespace mozilla { + +// Placeholder when no value is needed. +struct DDNoValue +{ +}; + +// Value capturing a range (typically an offset and a number of bytes in a +// resource). +struct DDRange +{ + const int64_t mOffset; + const int64_t mBytes; + DDRange(int64_t aOffset, int64_t aBytes) + : mOffset(aOffset) + , mBytes(aBytes) + { + } +}; + +// Value associated with a log message. +using DDLogValue = Variant; + +void +AppendToString(const DDLogValue& aValue, nsCString& aString); + +class JSONWriter; +void +ToJSON(const DDLogValue& aValue, + JSONWriter& aJSONWriter, + const char* aPropertyName); + +} // namespace mozilla + +#endif // DDLogValue_h_ diff --git a/dom/media/doctor/DDLoggedTypeTraits.h b/dom/media/doctor/DDLoggedTypeTraits.h new file mode 100644 index 000000000000..711391ee4000 --- /dev/null +++ b/dom/media/doctor/DDLoggedTypeTraits.h @@ -0,0 +1,110 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef DDLoggedTypeTraits_h_ +#define DDLoggedTypeTraits_h_ + +#include "mozilla/TypeTraits.h" + +namespace mozilla { + +// Templated struct carrying compile-time information about C++ types that may +// log messages (including about their lifetime and links to other objects.) +// Classes should declare a specialization by using one of the macros below. +template +struct DDLoggedTypeTraits; + +#define DDLoggedTypeName(TYPE) \ + template<> \ + struct DDLoggedTypeTraits \ + { \ + using Type = TYPE; \ + static constexpr const char* Name() { return #TYPE; } \ + using HasBase = FalseType; \ + using BaseType = TYPE; \ + static constexpr const char* BaseTypeName() { return ""; } \ + } + +#define DDLoggedTypeNameAndBase(TYPE, BASE) \ + template<> \ + struct DDLoggedTypeTraits \ + { \ + using Type = TYPE; \ + static constexpr const char* Name() { return #TYPE; } \ + using HasBase = TrueType; \ + using BaseType = BASE; \ + static constexpr const char* BaseTypeName() \ + { \ + return DDLoggedTypeTraits::Name(); \ + } \ + } + +#define DDLoggedTypeCustomName(TYPE, NAME) \ + template<> \ + struct DDLoggedTypeTraits \ + { \ + using Type = TYPE; \ + static constexpr const char* Name() { return #NAME; } \ + using HasBase = FalseType; \ + using BaseType = TYPE; \ + static constexpr const char* BaseTypeName() { return ""; } \ + } + +#define DDLoggedTypeCustomNameAndBase(TYPE, NAME, BASE) \ + template<> \ + struct DDLoggedTypeTraits \ + { \ + using Type = TYPE; \ + static constexpr const char* Name() { return #NAME; } \ + using HasBase = TrueType; \ + using BaseType = BASE; \ + static constexpr const char* BaseTypeName() \ + { \ + return DDLoggedTypeTraits::Name(); \ + } \ + } + +// Variants with built-in forward-declaration, will only work +// - in mozilla namespace, +// - with unqualified mozilla-namespace type names. +#define DDLoggedTypeDeclName(TYPE) \ + class TYPE; \ + DDLoggedTypeName(TYPE); +#define DDLoggedTypeDeclNameAndBase(TYPE, BASE) \ + class TYPE; \ + DDLoggedTypeNameAndBase(TYPE, BASE); +#define DDLoggedTypeDeclCustomName(TYPE, NAME) \ + class TYPE; \ + DDLoggedTypeCustomName(TYPE, NAME); +#define DDLoggedTypeDeclCustomNameAndBase(TYPE, NAME, BASE) \ + class TYPE; \ + DDLoggedTypeCustomNameAndBase(TYPE, NAME, BASE); + +} // namespace mozilla + +// Some essential types that live outside of the media stack. +class nsIDocument; +class nsPIDOMWindowInner; +class nsPIDOMWindowOuter; + +namespace mozilla { + +namespace dom { +class HTMLAudioElement; +class HTMLMediaElement; +class HTMLVideoElement; +} // namespace (mozilla/)dom + +DDLoggedTypeName(nsIDocument); +DDLoggedTypeName(nsPIDOMWindowInner); +DDLoggedTypeName(nsPIDOMWindowOuter); +DDLoggedTypeName(dom::HTMLMediaElement); +DDLoggedTypeNameAndBase(dom::HTMLAudioElement, dom::HTMLMediaElement); +DDLoggedTypeNameAndBase(dom::HTMLVideoElement, dom::HTMLMediaElement); + +} // namespace mozilla + +#endif // DDLoggedTypeTraits_h_ diff --git a/dom/media/doctor/DDMediaLog.cpp b/dom/media/doctor/DDMediaLog.cpp new file mode 100644 index 000000000000..8778d8655709 --- /dev/null +++ b/dom/media/doctor/DDMediaLog.cpp @@ -0,0 +1,29 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "DDMediaLog.h" + +namespace mozilla { + +size_t +DDMediaLog::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const +{ + size_t size = mMessages.ShallowSizeOfExcludingThis(aMallocSizeOf); + for (const DDLogMessage& message : mMessages) { + if (message.mValue.is()) { + size += + message.mValue.as().SizeOfExcludingThisIfUnshared( + aMallocSizeOf); + } else if (message.mValue.is()) { + size += message.mValue.as() + .Message() + .SizeOfExcludingThisIfUnshared(aMallocSizeOf); + } + } + return size; +} + +} // namespace mozilla diff --git a/dom/media/doctor/DDMediaLog.h b/dom/media/doctor/DDMediaLog.h new file mode 100644 index 000000000000..d0c49f100c32 --- /dev/null +++ b/dom/media/doctor/DDMediaLog.h @@ -0,0 +1,43 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef DDMediaLog_h_ +#define DDMediaLog_h_ + +#include "DDLogMessage.h" +#include "nsTArray.h" + +namespace mozilla { + +namespace dom { +class HTMLMediaElement; +} // namespace dom + +class DDLifetimes; + +// Container of processed messages corresponding to an HTMLMediaElement (or +// not yet). +struct DDMediaLog +{ + // Associated HTMLMediaElement, or nullptr for the DDMediaLog containing + // messages for yet-unassociated objects. + // TODO: Should use a DDLogObject instead, to distinguish between elements + // at the same address. + // Not critical: At worst we will combine logs for two elements. + const dom::HTMLMediaElement* mMediaElement; + + // Number of lifetimes associated with this log. Managed by DDMediaLogs. + int32_t mLifetimeCount = 0; + + using LogMessages = nsTArray; + LogMessages mMessages; + + size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const; +}; + +} // namespace mozilla + +#endif // DDMediaLog_h_ diff --git a/dom/media/doctor/DDMediaLogs.cpp b/dom/media/doctor/DDMediaLogs.cpp new file mode 100644 index 000000000000..4343fdc819c2 --- /dev/null +++ b/dom/media/doctor/DDMediaLogs.cpp @@ -0,0 +1,722 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "DDMediaLogs.h" + +#include "DDLogUtils.h" +#include "mozilla/JSONWriter.h" +#include "mozilla/SharedThreadPool.h" + +namespace mozilla { + +/* static */ DDMediaLogs::ConstructionResult +DDMediaLogs::New() +{ + nsCOMPtr mThread; + nsresult rv = NS_NewNamedThread("DDMediaLogs", + getter_AddRefs(mThread), + nullptr, + SharedThreadPool::kStackSize); + if (NS_WARN_IF(NS_FAILED(rv))) { + return { rv, nullptr }; + } + + return { rv, new DDMediaLogs(Move(mThread)) }; +} + +DDMediaLogs::DDMediaLogs(nsCOMPtr&& aThread) + : mMediaLogs(1) + , mMutex("DDMediaLogs") + , mThread(Move(aThread)) +{ + mMediaLogs.SetLength(1); + mMediaLogs[0].mMediaElement = nullptr; + DDL_INFO("DDMediaLogs constructed, processing thread: %p", mThread.get()); +} + +DDMediaLogs::~DDMediaLogs() +{ + // Perform end-of-life processing, ensure the processing thread is shutdown. + Shutdown(/* aPanic = */ false); +} + +void +DDMediaLogs::Panic() +{ + Shutdown(/* aPanic = */ true); +} + +void +DDMediaLogs::Shutdown(bool aPanic) +{ + nsCOMPtr thread; + { + MutexAutoLock lock(mMutex); + thread.swap(mThread); + } + if (!thread) { + // Already shutdown, nothing more to do. + return; + } + + DDL_INFO("DDMediaLogs::Shutdown will shutdown thread: %p", thread.get()); + // Will block until pending tasks have completed, and thread is dead. + thread->Shutdown(); + + if (aPanic) { + mMessagesQueue.PopAll([](const DDLogMessage&) {}); + MutexAutoLock lock(mMutex); + mLifetimes.Clear(); + mMediaLogs.Clear(); + mObjectLinks.Clear(); + mPendingPromises.Clear(); + return; + } + + // Final processing is only necessary to output to MOZ_LOG=DDLoggerEnd, + // so there's no point doing any of it if that MOZ_LOG is not enabled. + if (MOZ_LOG_TEST(sDecoderDoctorLoggerEndLog, mozilla::LogLevel::Info)) { + DDL_DEBUG("Perform final DDMediaLogs processing..."); + // The processing thread is dead, so we can safely call ProcessLog() + // directly from this thread. + ProcessLog(); + + for (const DDMediaLog& mediaLog : mMediaLogs) { + if (mediaLog.mMediaElement) { + DDLE_INFO("---"); + } + DDLE_INFO("--- Log for HTMLMediaElement[%p] ---", mediaLog.mMediaElement); + for (const DDLogMessage& message : mediaLog.mMessages) { + DDLE_LOG(message.mClass <= DDLogClass::_Unlink + ? mozilla::LogLevel::Debug + : mozilla::LogLevel::Info, + "%s", + message.Print(mLifetimes).get()); + } + DDLE_DEBUG("--- End log for HTMLMediaElement[%p] ---", + mediaLog.mMediaElement); + } + } +} + +DDMediaLog& +DDMediaLogs::LogForUnassociatedMessages() +{ + MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread()); + return mMediaLogs[0]; +} +const DDMediaLog& +DDMediaLogs::LogForUnassociatedMessages() const +{ + MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread()); + return mMediaLogs[0]; +} + +DDMediaLog* +DDMediaLogs::GetLogFor(const dom::HTMLMediaElement* aMediaElement) +{ + MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread()); + if (!aMediaElement) { + return &LogForUnassociatedMessages(); + } + for (DDMediaLog& log : mMediaLogs) { + if (log.mMediaElement == aMediaElement) { + return &log; + } + } + return nullptr; +} + +DDMediaLog& +DDMediaLogs::LogFor(const dom::HTMLMediaElement* aMediaElement) +{ + MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread()); + DDMediaLog* log = GetLogFor(aMediaElement); + if (!log) { + log = mMediaLogs.AppendElement(); + log->mMediaElement = aMediaElement; + } + return *log; +} + +void +DDMediaLogs::SetMediaElement(DDLifetime& aLifetime, + const dom::HTMLMediaElement* aMediaElement) +{ + MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread()); + DDMediaLog& log = LogFor(aMediaElement); + + // List of lifetimes that are to be linked to aMediaElement. + nsTArray lifetimes; + // We start with the given lifetime. + lifetimes.AppendElement(&aLifetime); + for (size_t i = 0; i < lifetimes.Length(); ++i) { + DDLifetime& lifetime = *lifetimes[i]; + // Link the lifetime to aMediaElement. + lifetime.mMediaElement = aMediaElement; + // Classified lifetime's tag is a positive index from the DDMediaLog. + lifetime.mTag = ++log.mLifetimeCount; + DDL_DEBUG( + "%s -> HTMLMediaElement[%p]", lifetime.Printf().get(), aMediaElement); + + // Go through the lifetime's existing linked lifetimes, if any is not + // already linked to aMediaElement, add it to the list so it will get + // linked in a later loop. + for (auto& link : mObjectLinks) { + if (lifetime.IsAliveAt(link.mLinkingIndex)) { + if (lifetime.mObject == link.mParent) { + DDLifetime* childLifetime = + mLifetimes.FindLifetime(link.mChild, link.mLinkingIndex); + if (childLifetime && !childLifetime->mMediaElement && + !lifetimes.Contains(childLifetime)) { + lifetimes.AppendElement(childLifetime); + } + } else if (lifetime.mObject == link.mChild) { + DDLifetime* parentLifetime = + mLifetimes.FindLifetime(link.mParent, link.mLinkingIndex); + if (parentLifetime && !parentLifetime->mMediaElement && + !lifetimes.Contains(parentLifetime)) { + lifetimes.AppendElement(parentLifetime); + } + } + } + } + } + + // Now we need to move yet-unclassified messages related to the just-set + // elements, to the appropriate MediaElement list. + DDMediaLog::LogMessages& messages = log.mMessages; + DDMediaLog::LogMessages& messages0 = LogForUnassociatedMessages().mMessages; + for (size_t i = 0; i < messages0.Length(); + /* increment inside the loop */) { + DDLogMessage& message = messages0[i]; + bool found = false; + for (const DDLifetime* lifetime : lifetimes) { + if (lifetime->mObject == message.mObject) { + found = true; + break; + } + } + if (found) { + messages.AppendElement(Move(message)); + messages0.RemoveElementAt(i); + // No increment, as we've removed this element; next element is now at + // the same index. + } else { + // Not touching this element, increment index to go to next element. + ++i; + } + } +} + +DDLifetime& +DDMediaLogs::FindOrCreateLifetime(const DDLogObject& aObject, + DDMessageIndex aIndex, + const DDTimeStamp& aTimeStamp) +{ + MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread()); + // Try to find lifetime corresponding to message object. + DDLifetime* lifetime = mLifetimes.FindLifetime(aObject, aIndex); + if (!lifetime) { + // No lifetime yet, create one. + lifetime = &(mLifetimes.CreateLifetime(aObject, aIndex, aTimeStamp)); + if (MOZ_UNLIKELY(aObject.TypeName() == + DDLoggedTypeTraits::Name())) { + const dom::HTMLMediaElement* mediaElement = + static_cast(aObject.Pointer()); + SetMediaElement(*lifetime, mediaElement); + DDL_DEBUG("%s -> new lifetime: %s with MediaElement %p", + aObject.Printf().get(), + lifetime->Printf().get(), + mediaElement); + } else { + DDL_DEBUG("%s -> new lifetime: %s", + aObject.Printf().get(), + lifetime->Printf().get()); + } + } + + return *lifetime; +} + +void +DDMediaLogs::LinkLifetimes(DDLifetime& aParentLifetime, + const char* aLinkName, + DDLifetime& aChildLifetime, + DDMessageIndex aIndex) +{ + MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread()); + mObjectLinks.AppendElement(DDObjectLink{ + aParentLifetime.mObject, aChildLifetime.mObject, aLinkName, aIndex }); + if (aParentLifetime.mMediaElement) { + if (!aChildLifetime.mMediaElement) { + SetMediaElement(aChildLifetime, aParentLifetime.mMediaElement); + } + } else if (aChildLifetime.mMediaElement) { + if (!aParentLifetime.mMediaElement) { + SetMediaElement(aParentLifetime, aChildLifetime.mMediaElement); + } + } +} + +void +DDMediaLogs::UnlinkLifetime(DDLifetime& aLifetime, DDMessageIndex aIndex) +{ + MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread()); + for (DDObjectLink& link : mObjectLinks) { + if ((link.mParent == aLifetime.mObject || + link.mChild == aLifetime.mObject) && + aLifetime.IsAliveAt(link.mLinkingIndex) && !link.mUnlinkingIndex) { + link.mUnlinkingIndex = Some(aIndex); + } + } +}; + +void +DDMediaLogs::UnlinkLifetimes(DDLifetime& aParentLifetime, + DDLifetime& aChildLifetime, + DDMessageIndex aIndex) +{ + MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread()); + for (DDObjectLink& link : mObjectLinks) { + if ((link.mParent == aParentLifetime.mObject && + link.mChild == aChildLifetime.mObject) && + aParentLifetime.IsAliveAt(link.mLinkingIndex) && + aChildLifetime.IsAliveAt(link.mLinkingIndex) && !link.mUnlinkingIndex) { + link.mUnlinkingIndex = Some(aIndex); + } + } +} + +void +DDMediaLogs::DestroyLifetimeLinks(const DDLifetime& aLifetime) +{ + mObjectLinks.RemoveElementsBy([&](DDObjectLink& link) { + return (link.mParent == aLifetime.mObject || + link.mChild == aLifetime.mObject) && + aLifetime.IsAliveAt(link.mLinkingIndex); + }); +} + +size_t +DDMediaLogs::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const +{ + size_t size = aMallocSizeOf(this) + + mLifetimes.SizeOfExcludingThis(aMallocSizeOf) + + mMediaLogs.ShallowSizeOfExcludingThis(aMallocSizeOf) + + mObjectLinks.ShallowSizeOfExcludingThis(aMallocSizeOf) + + mPendingPromises.ShallowSizeOfExcludingThis(aMallocSizeOf); + for (const DDMediaLog& log : mMediaLogs) { + size += log.SizeOfExcludingThis(aMallocSizeOf); + } + return size; +} + +void +DDMediaLogs::ProcessBuffer() +{ + MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread()); + + mMessagesQueue.PopAll([this](const DDLogMessage& message) { + DDL_DEBUG("Processing: %s", message.Print().Data()); + + // Either this message will carry a new object for which to create a + // lifetime, or we'll find an existing one. + DDLifetime& lifetime = + FindOrCreateLifetime(message.mObject, message.mIndex, message.mTimeStamp); + + // Copy the message contents (without the mValid flag) to the + // appropriate MediaLog corresponding to the message's object lifetime. + LogFor(lifetime.mMediaElement) + .mMessages.AppendElement(static_cast(message)); + + switch (message.mClass) { + case DDLogClass::_Construction: + // The FindOrCreateLifetime above will have set a construction time, + // so there's nothing more we need to do here. + MOZ_ASSERT(lifetime.mConstructionTimeStamp); + break; + + case DDLogClass::_DerivedConstruction: + // The FindOrCreateLifetime above will have set a construction time. + MOZ_ASSERT(lifetime.mConstructionTimeStamp); + // A derived construction must come with the base object. + MOZ_ASSERT(message.mValue.is()); + { + const DDLogObject& base = message.mValue.as(); + DDLifetime& baseLifetime = + FindOrCreateLifetime(base, message.mIndex, message.mTimeStamp); + // FindOrCreateLifetime could have moved `lifetime`. + DDLifetime* lifetime2 = + mLifetimes.FindLifetime(message.mObject, message.mIndex); + MOZ_ASSERT(lifetime2); + // Assume there's no multiple-inheritance (at least for the types + // we're watching.) + if (baseLifetime.mDerivedObject.Pointer()) { + DDL_WARN( + "base '%s' was already derived as '%s', now deriving as '%s'", + baseLifetime.Printf().get(), + baseLifetime.mDerivedObject.Printf().get(), + lifetime2->Printf().get()); + } + baseLifetime.mDerivedObject = lifetime2->mObject; + baseLifetime.mDerivedObjectLinkingIndex = message.mIndex; + // Link the base and derived objects, to ensure they go to the same + // log. + LinkLifetimes(*lifetime2, "is-a", baseLifetime, message.mIndex); + } + break; + + case DDLogClass::_Destruction: + lifetime.mDestructionIndex = message.mIndex; + lifetime.mDestructionTimeStamp = message.mTimeStamp; + UnlinkLifetime(lifetime, message.mIndex); + break; + + case DDLogClass::_Link: + MOZ_ASSERT(message.mValue.is()); + { + const DDLogObject& child = message.mValue.as(); + DDLifetime& childLifetime = + FindOrCreateLifetime(child, message.mIndex, message.mTimeStamp); + // FindOrCreateLifetime could have moved `lifetime`. + DDLifetime* lifetime2 = + mLifetimes.FindLifetime(message.mObject, message.mIndex); + MOZ_ASSERT(lifetime2); + LinkLifetimes( + *lifetime2, message.mLabel, childLifetime, message.mIndex); + } + break; + + case DDLogClass::_Unlink: + MOZ_ASSERT(message.mValue.is()); + { + const DDLogObject& child = message.mValue.as(); + DDLifetime& childLifetime = + FindOrCreateLifetime(child, message.mIndex, message.mTimeStamp); + // FindOrCreateLifetime could have moved `lifetime`. + DDLifetime* lifetime2 = + mLifetimes.FindLifetime(message.mObject, message.mIndex); + MOZ_ASSERT(lifetime2); + UnlinkLifetimes(*lifetime2, childLifetime, message.mIndex); + } + break; + + default: + // Anything else: Nothing more to do. + break; + } + }); +} + +struct StringWriteFunc : public JSONWriteFunc +{ + nsCString& mCString; + explicit StringWriteFunc(nsCString& aCString) + : mCString(aCString) + { + } + void Write(const char* aStr) override { mCString.Append(aStr); } +}; + +void +DDMediaLogs::FulfillPromises() +{ + MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread()); + + MozPromiseHolder promiseHolder; + const dom::HTMLMediaElement* mediaElement = nullptr; + { + // Grab the first pending promise (if any). + // Note that we don't pop it yet, so we don't potentially leave the list + // empty and therefore allow another processing task to be dispatched. + MutexAutoLock lock(mMutex); + if (mPendingPromises.IsEmpty()) { + return; + } + promiseHolder = Move(mPendingPromises[0].mPromiseHolder); + mediaElement = mPendingPromises[0].mMediaElement; + } + for (;;) { + DDMediaLog* log = GetLogFor(mediaElement); + if (!log) { + // No such media element -> Reject this promise. + DDL_INFO("Rejecting promise for HTMLMediaElement[%p] - Cannot find log", + mediaElement); + promiseHolder.Reject(NS_ERROR_DOM_MEDIA_NOT_ALLOWED_ERR, __func__); + // Pop this rejected promise, fetch next one. + MutexAutoLock lock(mMutex); + mPendingPromises.RemoveElementAt(0); + if (mPendingPromises.IsEmpty()) { + break; + } + promiseHolder = Move(mPendingPromises[0].mPromiseHolder); + mediaElement = mPendingPromises[0].mMediaElement; + continue; + } + + nsCString json; + JSONWriter jw{ MakeUnique(json) }; + jw.Start(); + jw.StartArrayProperty("messages"); + for (const DDLogMessage& message : log->mMessages) { + jw.StartObjectElement(JSONWriter::SingleLineStyle); + jw.IntProperty("i", message.mIndex.Value()); + jw.DoubleProperty("ts", ToSeconds(message.mTimeStamp)); + DDLifetime* lifetime = + mLifetimes.FindLifetime(message.mObject, message.mIndex); + if (lifetime) { + jw.IntProperty("ob", lifetime->mTag); + } else { + jw.StringProperty("ob", + nsPrintfCString(R"("%s[%p]")", + message.mObject.TypeName(), + message.mObject.Pointer()) + .get()); + } + jw.StringProperty("cls", ToShortString(message.mClass)); + if (message.mLabel && message.mLabel[0] != '\0') { + jw.StringProperty("lbl", message.mLabel); + } + if (!message.mValue.is()) { + if (message.mValue.is()) { + const DDLogObject& ob2 = message.mValue.as(); + DDLifetime* lifetime2 = mLifetimes.FindLifetime(ob2, message.mIndex); + if (lifetime2) { + jw.IntProperty("val", lifetime2->mTag); + } else { + ToJSON(message.mValue, jw, "val"); + } + } else { + ToJSON(message.mValue, jw, "val"); + } + } + jw.EndObject(); + } + jw.EndArray(); + jw.StartObjectProperty("objects"); + mLifetimes.Visit( + mediaElement, + [&](const DDLifetime& lifetime) { + jw.StartObjectProperty(nsPrintfCString("%" PRIi32, lifetime.mTag).get(), + JSONWriter::SingleLineStyle); + jw.IntProperty("tag", lifetime.mTag); + jw.StringProperty("cls", lifetime.mObject.TypeName()); + jw.StringProperty( + "ptr", nsPrintfCString("%p", lifetime.mObject.Pointer()).get()); + jw.IntProperty("con", lifetime.mConstructionIndex.Value()); + jw.DoubleProperty("con_ts", ToSeconds(lifetime.mConstructionTimeStamp)); + if (lifetime.mDestructionTimeStamp) { + jw.IntProperty("des", lifetime.mDestructionIndex.Value()); + jw.DoubleProperty("des_ts", + ToSeconds(lifetime.mDestructionTimeStamp)); + } + if (lifetime.mDerivedObject.Pointer()) { + DDLifetime* derived = mLifetimes.FindLifetime( + lifetime.mDerivedObject, lifetime.mDerivedObjectLinkingIndex); + if (derived) { + jw.IntProperty("drvd", derived->mTag); + } + } + jw.EndObject(); + }, + // If there were no (new) messages, only give the main HTMLMediaElement + // object (used to identify this log against the correct element.) + log->mMessages.IsEmpty()); + jw.EndObject(); + jw.End(); + DDL_DEBUG("RetrieveMessages(%p) ->\n%s", mediaElement, json.get()); + + // This log exists (new messages or not) -> Resolve this promise. + DDL_INFO("Resolving promise for HTMLMediaElement[%p] with messages %" PRImi + "-%" PRImi, + mediaElement, + log->mMessages.IsEmpty() ? 0 : log->mMessages[0].mIndex.Value(), + log->mMessages.IsEmpty() + ? 0 + : log->mMessages[log->mMessages.Length() - 1].mIndex.Value()); + promiseHolder.Resolve(Move(json), __func__); + + // Remove exported messages. + log->mMessages.Clear(); + + // Pop this resolved promise, fetch next one. + MutexAutoLock lock(mMutex); + mPendingPromises.RemoveElementAt(0); + if (mPendingPromises.IsEmpty()) { + break; + } + promiseHolder = Move(mPendingPromises[0].mPromiseHolder); + mediaElement = mPendingPromises[0].mMediaElement; + } +} + +void +DDMediaLogs::CleanUpLogs() +{ + MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread()); + + DDTimeStamp now = DDNow(); + + // Keep up to 30s of unclassified messages (if a message doesn't get + // classified this quickly, it probably never will be.) + static const double sMaxAgeUnclassifiedMessages_s = 30.0; + // Keep "dead" log (video element and dependents were destroyed) for up to + // 2 minutes, in case the user wants to look at it after the facts. + static const double sMaxAgeDeadLog_s = 120.0; + // Keep old messages related to a live video for up to 5 minutes. + static const double sMaxAgeClassifiedMessages_s = 300.0; + + for (size_t logIndexPlus1 = mMediaLogs.Length(); logIndexPlus1 != 0; + --logIndexPlus1) { + DDMediaLog& log = mMediaLogs[logIndexPlus1 - 1]; + if (log.mMediaElement) { + // Remove logs for which no lifetime still existed some time ago. + bool used = mLifetimes.VisitBreakable( + log.mMediaElement, [&](const DDLifetime& lifetime) { + // Do we still have a lifetime that existed recently enough? + return !lifetime.mDestructionTimeStamp || + (now - lifetime.mDestructionTimeStamp).ToSeconds() <= + sMaxAgeDeadLog_s; + }); + if (!used) { + DDL_INFO("Removed old log for media element %p", log.mMediaElement); + mLifetimes.Visit(log.mMediaElement, [&](const DDLifetime& lifetime) { + DestroyLifetimeLinks(lifetime); + }); + mLifetimes.RemoveLifetimesFor(log.mMediaElement); + mMediaLogs.RemoveElementAt(logIndexPlus1 - 1); + continue; + } + } + + // Remove old messages. + size_t old = 0; + const size_t len = log.mMessages.Length(); + while (old < len && (now - log.mMessages[old].mTimeStamp).ToSeconds() > + (log.mMediaElement ? sMaxAgeClassifiedMessages_s + : sMaxAgeUnclassifiedMessages_s)) { + ++old; + } + if (old != 0) { + // We are going to remove `old` messages. + // First, remove associated destroyed lifetimes that are not used after + // these old messages. (We want to keep non-destroyed lifetimes, in + // case they get used later on.) + size_t removedLifetimes = 0; + for (size_t i = 0; i < old; ++i) { + auto RemoveDestroyedUnusedLifetime = [&](DDLifetime* lifetime) { + if (!lifetime->mDestructionTimeStamp) { + // Lifetime is still alive, keep it. + return; + } + bool used = false; + for (size_t after = old; after < len; ++after) { + const DDLogMessage message = log.mMessages[i]; + if (!lifetime->IsAliveAt(message.mIndex)) { + // Lifetime is already dead, and not used yet -> kill it. + break; + } + const DDLogObject& ob = message.mObject; + if (lifetime->mObject == ob) { + used = true; + break; + } + if (message.mValue.is()) { + if (lifetime->mObject == message.mValue.as()) { + used = true; + break; + } + } + } + if (!used) { + DestroyLifetimeLinks(*lifetime); + mLifetimes.RemoveLifetime(lifetime); + ++removedLifetimes; + } + }; + + const DDLogMessage message = log.mMessages[i]; + const DDLogObject& ob = message.mObject; + + DDLifetime* lifetime1 = mLifetimes.FindLifetime(ob, message.mIndex); + if (lifetime1) { + RemoveDestroyedUnusedLifetime(lifetime1); + } + + if (message.mValue.is()) { + DDLifetime* lifetime2 = mLifetimes.FindLifetime( + message.mValue.as(), message.mIndex); + if (lifetime2) { + RemoveDestroyedUnusedLifetime(lifetime2); + } + } + } + DDL_INFO("Removed %zu messages (#%" PRImi " %f - #%" PRImi + " %f) and %zu lifetimes from log for media element %p", + old, + log.mMessages[0].mIndex.Value(), + ToSeconds(log.mMessages[0].mTimeStamp), + log.mMessages[old - 1].mIndex.Value(), + ToSeconds(log.mMessages[old - 1].mTimeStamp), + removedLifetimes, + log.mMediaElement); + log.mMessages.RemoveElementsAt(0, old); + } + } +} + +void +DDMediaLogs::ProcessLog() +{ + MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread()); + ProcessBuffer(); + FulfillPromises(); + CleanUpLogs(); + DDL_INFO("DDMediaLog size: %zu", SizeOfIncludingThis(moz_malloc_size_of)); +} + +nsresult +DDMediaLogs::DispatchProcessLog(const MutexAutoLock& aProofOfLock) +{ + if (!mThread) { + return NS_ERROR_SERVICE_NOT_AVAILABLE; + } + return mThread->Dispatch( + NS_NewRunnableFunction("ProcessLog", [this] { ProcessLog(); }), + NS_DISPATCH_NORMAL); +} + +nsresult +DDMediaLogs::DispatchProcessLog() +{ + MutexAutoLock lock(mMutex); + return DispatchProcessLog(lock); +} + +RefPtr +DDMediaLogs::RetrieveMessages(const dom::HTMLMediaElement* aMediaElement) +{ + MozPromiseHolder holder; + RefPtr promise = holder.Ensure(__func__); + { + MutexAutoLock lock(mMutex); + // If there were unfulfilled promises, we know processing has already + // been requested. + if (mPendingPromises.IsEmpty()) { + // But if we're the first one, start processing. + nsresult rv = DispatchProcessLog(lock); + if (NS_FAILED(rv)) { + holder.Reject(rv, __func__); + } + } + mPendingPromises.AppendElement( + PendingPromise{ Move(holder), aMediaElement }); + } + return promise; +} + +} // namespace mozilla diff --git a/dom/media/doctor/DDMediaLogs.h b/dom/media/doctor/DDMediaLogs.h new file mode 100644 index 000000000000..3aba0d976313 --- /dev/null +++ b/dom/media/doctor/DDMediaLogs.h @@ -0,0 +1,207 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef DDMediaLogs_h_ +#define DDMediaLogs_h_ + +#include "DDLifetimes.h" +#include "DDMediaLog.h" +#include "mozilla/MozPromise.h" +#include "MultiWriterQueue.h" + +namespace mozilla { + +// Main object managing all processed logs, and yet-unprocessed messages. +struct DDMediaLogs +{ +public: + // Construct a DDMediaLogs object if possible. + struct ConstructionResult + { + nsresult mRv; + DDMediaLogs* mMediaLogs; + }; + static ConstructionResult New(); + + // If not already shutdown, performs normal end-of-life processing, and shuts + // down the processing thread (blocking). + ~DDMediaLogs(); + + // Shutdown the processing thread (blocking), and free as much memory as + // possible. + void Panic(); + + inline void Log(const char* aSubjectTypeName, + const void* aSubjectPointer, + DDLogClass aClass, + const char* aLabel, + DDLogValue&& aValue) + { + if (mMessagesQueue.PushF( + [&](DDLogMessage& aMessage, MessagesQueue::Index i) { + aMessage.mIndex = i; + aMessage.mTimeStamp = DDNow(); + aMessage.mObject.Set(aSubjectTypeName, aSubjectPointer); + aMessage.mClass = aClass; + aMessage.mLabel = aLabel; + aMessage.mValue = Move(aValue); + })) { + // Filled a buffer-full of messages, process it in another thread. + DispatchProcessLog(); + } + } + + // Process the log right now; should only be used on the processing thread, + // or after shutdown for end-of-life log retrieval. Work includes: + // - Processing incoming buffers, to update object lifetimes and links; + // - Resolve pending promises that requested logs; + // - Clean-up old logs from memory. + void ProcessLog(); + + using LogMessagesPromise = + MozPromise; + + // Retrieve all messages associated with an HTMLMediaElement. + // This will trigger an async processing run (to ensure most recent messages + // get retrieved too), and the returned promise will be resolved with all + // found log messages. + RefPtr RetrieveMessages( + const dom::HTMLMediaElement* aMediaElement); + + size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const; + +private: + // Constructor, takes the given thread to use for log processing. + explicit DDMediaLogs(nsCOMPtr&& aThread); + + // Shutdown the processing thread, blocks until that thread exits. + // If aPanic is true, just free as much memory as possible. + // Otherwise, perform a final processing run, output end-logs (if enabled). + void Shutdown(bool aPanic); + + // Get the log of yet-unassociated messages. + DDMediaLog& LogForUnassociatedMessages(); + const DDMediaLog& LogForUnassociatedMessages() const; + + // Get the log for the given HTMLMediaElement. Returns nullptr if there is no + // such log yet. + DDMediaLog* GetLogFor(const dom::HTMLMediaElement* aMediaElement); + + // Get the log for the given HTMLMediaElement. + // A new log is created if that element didn't already have one. + DDMediaLog& LogFor(const dom::HTMLMediaElement* aMediaElement); + + // Associate a lifetime, and all its already-linked lifetimes, with an + // HTMLMediaElement. + // All messages involving the modified lifetime(s) are moved to the + // corresponding log. + void SetMediaElement(DDLifetime& aLifetime, + const dom::HTMLMediaElement* aMediaElement); + + // Find the lifetime corresponding to an object (known type and pointer) that + // was known to be alive at aIndex. + // If there is no such lifetime yet, create it with aTimeStamp as implicit + // construction timestamp. + // If the object is of type HTMLMediaElement, run SetMediaElement() on it. + DDLifetime& FindOrCreateLifetime(const DDLogObject& aObject, + DDMessageIndex aIndex, + const DDTimeStamp& aTimeStamp); + + // Link two lifetimes together (at a given time corresponding to aIndex). + // If only one is associated with an HTMLMediaElement, run SetMediaElement on + // the other one. + void LinkLifetimes(DDLifetime& aParentLifetime, + const char* aLinkName, + DDLifetime& aChildLifetime, + DDMessageIndex aIndex); + + // Unlink all lifetimes linked to aLifetime; only used to know when links + // expire, so that they won't be used after this time. + void UnlinkLifetime(DDLifetime& aLifetime, DDMessageIndex aIndex); + + // Unlink two lifetimes; only used to know when a link expires, so that it + // won't be used after this time. + void UnlinkLifetimes(DDLifetime& aParentLifetime, + DDLifetime& aChildLifetime, + DDMessageIndex aIndex); + + // Remove all links involving aLifetime from the database. + void DestroyLifetimeLinks(const DDLifetime& aLifetime); + + // Process all incoming log messages. + // This will create the appropriate DDLifetime and links objects, and then + // move processed messages to logs associated with different + // HTMLMediaElements. + void ProcessBuffer(); + + // Pending promises (added by RetrieveMessages) are resolved with all new + // log messages corresponding to requested HTMLMediaElements -- These + // messages are removed from our logs. + void FulfillPromises(); + + // Remove processed messages that have a low chance of being requested, + // based on the assumption that users/scripts will regularly call + // RetrieveMessages for HTMLMediaElements they are interested in. + void CleanUpLogs(); + + // Request log-processing on the processing thread. Thread-safe. + nsresult DispatchProcessLog(); + + // Request log-processing on the processing thread. + nsresult DispatchProcessLog(const MutexAutoLock& aProofOfLock); + + using MessagesQueue = MultiWriterQueue; + MessagesQueue mMessagesQueue; + + DDLifetimes mLifetimes; + + // mMediaLogs[0] contains unsorted message (with mMediaElement=nullptr). + // mMediaLogs[1+] contains sorted messages for each media element. + nsTArray mMediaLogs; + + struct DDObjectLink + { + const DDLogObject mParent; + const DDLogObject mChild; + const char* const mLinkName; + const DDMessageIndex mLinkingIndex; + Maybe mUnlinkingIndex; + + DDObjectLink(DDLogObject aParent, + DDLogObject aChild, + const char* aLinkName, + DDMessageIndex aLinkingIndex) + : mParent(aParent) + , mChild(aChild) + , mLinkName(aLinkName) + , mLinkingIndex(aLinkingIndex) + , mUnlinkingIndex(Nothing{}) + { + } + }; + // Links between live objects, updated while messages are processed. + nsTArray mObjectLinks; + + // Protects members below. + Mutex mMutex; + + // Processing thread. + nsCOMPtr mThread; + + struct PendingPromise + { + MozPromiseHolder mPromiseHolder; + const dom::HTMLMediaElement* mMediaElement; + }; + // Most cases should have 1 media panel requesting 1 promise at a time. + AutoTArray mPendingPromises; +}; + +} // namespace mozilla + +#endif // DDMediaLogs_h_ diff --git a/dom/media/doctor/DDMessageIndex.h b/dom/media/doctor/DDMessageIndex.h new file mode 100644 index 000000000000..e8bcb507d82b --- /dev/null +++ b/dom/media/doctor/DDMessageIndex.h @@ -0,0 +1,26 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef DDMessageIndex_h_ +#define DDMessageIndex_h_ + +#include "RollingNumber.h" + +namespace mozilla { + +// Type used to uniquely identify and sort log messages. +// We assume that a given media element won't live for more than the time taken +// to log 2^31 messages (per process); for 10,000 messages per seconds, that's +// about 2.5 days +using DDMessageIndex = RollingNumber; + +// Printf string constant to use when printing a DDMessageIndex, e.g.: +// `printf("index=%" PRImi, index);` +#define PRImi PRIu32 + +} // namespace mozilla + +#endif // DDMessageIndex_h_ diff --git a/dom/media/doctor/DDTimeStamp.cpp b/dom/media/doctor/DDTimeStamp.cpp new file mode 100644 index 000000000000..ff4443e8c5de --- /dev/null +++ b/dom/media/doctor/DDTimeStamp.cpp @@ -0,0 +1,22 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "DDTimeStamp.h" + +namespace mozilla { + +double +ToSeconds(const DDTimeStamp& aTimeStamp) +{ + // Timestamp at first call, used internally to convert log timestamps + // to a duration from this timestamp. + // What's important is the relative time between log messages. + static const DDTimeStamp sInitialTimeStamp = TimeStamp::Now(); + + return (aTimeStamp - sInitialTimeStamp).ToSeconds(); +} + +} // namespace mozilla diff --git a/dom/media/doctor/DDTimeStamp.h b/dom/media/doctor/DDTimeStamp.h new file mode 100644 index 000000000000..5e569dc03b2e --- /dev/null +++ b/dom/media/doctor/DDTimeStamp.h @@ -0,0 +1,29 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef DDTimeStamp_h_ +#define DDTimeStamp_h_ + +#include "mozilla/TimeStamp.h" + +namespace mozilla { + +// Simply using mozilla::TimeStamp as our timestamp type. +using DDTimeStamp = TimeStamp; + +inline DDTimeStamp +DDNow() +{ + return TimeStamp::Now(); +} + +// Convert a timestamp to the number of seconds since the process start. +double +ToSeconds(const DDTimeStamp& aTimeStamp); + +} // namespace mozilla + +#endif // DDTimeStamp_h_ diff --git a/dom/media/doctor/DecoderDoctorLogger.cpp b/dom/media/doctor/DecoderDoctorLogger.cpp new file mode 100644 index 000000000000..4059490d3af0 --- /dev/null +++ b/dom/media/doctor/DecoderDoctorLogger.cpp @@ -0,0 +1,171 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "DecoderDoctorLogger.h" + +#include "DDLogUtils.h" +#include "DDMediaLogs.h" +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/SystemGroup.h" +#include "mozilla/Unused.h" + +namespace mozilla { + +/* static */ Atomic + DecoderDoctorLogger::sLogState{ DecoderDoctorLogger::scDisabled }; + +/* static */ const char* DecoderDoctorLogger::sShutdownReason = nullptr; + +static DDMediaLogs* sMediaLogs; + +// First DDLogShutdowner sets sLogState to scShutdown, to prevent further +// logging. +struct DDLogShutdowner +{ + ~DDLogShutdowner() + { + DDL_INFO("Shutting down"); + // Prevent further logging, some may racily seep in, it's fine as the + // logging infrastructure would still be alive until DDLogDeleter runs. + DecoderDoctorLogger::ShutdownLogging(); + } +}; +static UniquePtr sDDLogShutdowner; + +// Later DDLogDeleter will delete the message queue and media logs. +struct DDLogDeleter +{ + ~DDLogDeleter() + { + if (sMediaLogs) { + DDL_INFO("Final processing of collected logs"); + delete sMediaLogs; + sMediaLogs = nullptr; + } + } +}; +static UniquePtr sDDLogDeleter; + +/* static */ void +DecoderDoctorLogger::PanicInternal(const char* aReason, bool aDontBlock) +{ + for (;;) { + const LogState state = static_cast(sLogState); + if (state == scEnabling && !aDontBlock) { + // Wait for the end of the enabling process (unless we're in it, in which + // case we don't want to block.) + continue; + } + if (state == scShutdown) { + // Already shutdown, nothing more to do. + break; + } + if (sLogState.compareExchange(state, scShutdown)) { + // We are the one performing the first shutdown -> Record reason. + sShutdownReason = aReason; + // Free as much memory as possible. + if (sMediaLogs) { + // Shutdown the medialogs processing thread, and free as much memory + // as possible. + sMediaLogs->Panic(); + } + // sMediaLogs and sQueue will be deleted by DDLogDeleter. + // We don't want to delete them right now, because there could be a race + // where another thread started logging or retrieving logs before we + // changed the state to scShutdown, but has been delayed before actually + // trying to write or read log messages, thereby causing a UAF. + } + // If someone else changed the state, we'll just loop around, and either + // shutdown already happened elsewhere, or we'll try to shutdown again. + } +} + +/* static */ bool +DecoderDoctorLogger::EnsureLogIsEnabled() +{ + for (;;) { + LogState state = static_cast(sLogState); + switch (state) { + case scDisabled: + // Currently disabled, try to be the one to enable. + if (sLogState.compareExchange(scDisabled, scEnabling)) { + // We are the one to enable logging, state won't change (except for + // possible shutdown.) + // Create DDMediaLogs singleton, which will process the message queue. + DDMediaLogs::ConstructionResult mediaLogsConstruction = + DDMediaLogs::New(); + if (NS_FAILED(mediaLogsConstruction.mRv)) { + PanicInternal("Failed to enable logging", /* aDontBlock */ true); + return false; + } + MOZ_ASSERT(mediaLogsConstruction.mMediaLogs); + sMediaLogs = mediaLogsConstruction.mMediaLogs; + // Setup shutdown-time clean-up. + MOZ_ALWAYS_SUCCEEDS(SystemGroup::Dispatch( + TaskCategory::Other, + NS_NewRunnableFunction("DDLogger shutdown setup", [] { + sDDLogShutdowner = MakeUnique(); + ClearOnShutdown(&sDDLogShutdowner, ShutdownPhase::Shutdown); + sDDLogDeleter = MakeUnique(); + ClearOnShutdown(&sDDLogDeleter, ShutdownPhase::ShutdownThreads); + }))); + + // Nobody else should change the state when *we* are enabling logging. + MOZ_ASSERT(sLogState == scEnabling); + sLogState = scEnabled; + DDL_INFO("Logging enabled"); + return true; + } + // Someone else changed the state before our compareExchange, just loop + // around to examine the new situation. + break; + case scEnabled: + return true; + case scEnabling: + // Someone else is currently enabling logging, actively wait by just + // looping, until the state changes. + break; + case scShutdown: + // Shutdown is non-recoverable, we cannot enable logging again. + return false; + } + // Not returned yet, loop around to examine the new situation. + } +} + +/* static */ void +DecoderDoctorLogger::EnableLogging() +{ + Unused << EnsureLogIsEnabled(); +} + +/* static */ RefPtr +DecoderDoctorLogger::RetrieveMessages( + const dom::HTMLMediaElement* aMediaElement) +{ + if (MOZ_UNLIKELY(!EnsureLogIsEnabled())) { + DDL_WARN("Request (for %p) but there are no logs", aMediaElement); + return DecoderDoctorLogger::LogMessagesPromise::CreateAndReject( + NS_ERROR_DOM_MEDIA_ABORT_ERR, __func__); + } + return sMediaLogs->RetrieveMessages(aMediaElement); +} + +/* static */ void +DecoderDoctorLogger::Log(const char* aSubjectTypeName, + const void* aSubjectPointer, + DDLogClass aClass, + const char* aLabel, + DDLogValue&& aValue) +{ + if (IsDDLoggingEnabled()) { + MOZ_ASSERT(sMediaLogs); + sMediaLogs->Log( + aSubjectTypeName, aSubjectPointer, aClass, aLabel, Move(aValue)); + } +} + +} // namespace mozilla diff --git a/dom/media/doctor/DecoderDoctorLogger.h b/dom/media/doctor/DecoderDoctorLogger.h new file mode 100644 index 000000000000..64c2957c29e8 --- /dev/null +++ b/dom/media/doctor/DecoderDoctorLogger.h @@ -0,0 +1,461 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef DecoderDoctorLogger_h_ +#define DecoderDoctorLogger_h_ + +#include "DDLoggedTypeTraits.h" +#include "DDLogClass.h" +#include "DDLogValue.h" +#include "mozilla/Atomics.h" +#include "mozilla/DefineEnum.h" +#include "mozilla/MozPromise.h" +#include "nsString.h" + +namespace mozilla { + +// Main class used to capture log messages from the media stack, and to +// retrieve processed messages associated with an HTMLMediaElement. +// +// The logging APIs are designed to work as fast as possible (in most cases +// only checking a couple of atomic variables, and not allocating memory), so +// as not to introduce perceptible latency. +// Consider using DDLOG...() macros, and IsDDLoggingEnabled(), to avoid any +// unneeded work when logging is not enabled. +// +// Structural logging messages are used to determine when objects are created +// and destroyed, and to link objects that depend on each other, ultimately +// tying groups of objects and their messages to HTMLMediaElement objects. +// +// A separate thread processes log messages, and can asynchronously retrieve +// processed messages that correspond to a given HTMLMediaElement. +// That thread is also responsible for removing dated messages, so as not to +// take too much memory. +class DecoderDoctorLogger +{ +public: + // Is logging currently enabled? This is tested anyway in all public `Log...` + // functions, but it may be used to prevent logging-only work in clients. + static inline bool IsDDLoggingEnabled() + { + return MOZ_UNLIKELY(static_cast(sLogState) == scEnabled); + } + + // Shutdown logging. This will prevent more messages to be queued, but the + // already-queued messages may still get processed. + static void ShutdownLogging() { sLogState = scShutdown; } + + // Something went horribly wrong, stop all logging and log processing. + static void Panic(const char* aReason) + { + PanicInternal(aReason, /* aDontBlock */ false); + } + + // Logging functions. + // + // All logging functions take: + // - The object that produces the message, either as a template type (for + // which a specialized DDLoggedTypeTraits exists), or a pointer and a type + // name (needed for inner classes that cannot specialize DDLoggedTypeTraits.) + // - A DDLogClass defining the type of log message; some are used + // internally for capture the lifetime and linking of C++ objects, others + // are used to split messages into different domains. + // - A label (string literal). + // - An optional Variant value, see DDLogValue for the accepted types. + // + // The following `EagerLog...` functions always cause their arguments to be + // pre-evaluated even if logging is disabled, in which case runtime could be + // wasted. Consider using `DDLOG...` macros instead, or test + // `IsDDLoggingEnabled()` first. + + template + static void EagerLogValue(const char* aSubjectTypeName, + const void* aSubjectPointer, + DDLogClass aClass, + const char* aLabel, + Value&& aValue) + { + Log(aSubjectTypeName, + aSubjectPointer, + aClass, + aLabel, + DDLogValue{ Forward(aValue) }); + } + + template + static void EagerLogValue(const Subject* aSubject, + DDLogClass aClass, + const char* aLabel, + Value&& aValue) + { + EagerLogValue(DDLoggedTypeTraits::Name(), + aSubject, + aClass, + aLabel, + Forward(aValue)); + } + + // LogValue with a string literal, as they are not seen as `const char*` by + // Variant. Also, a literal doesn't have runtime costs, so it's cheap to call + // directly. + template + static void LogValue(const char* aSubjectTypeName, + const void* aSubjectPointer, + DDLogClass aClass, + const char* aLabel, + const char (&aLiteral)[N]) + { + EagerLogValue(aSubjectTypeName, + aSubjectPointer, + aClass, + aLabel, + static_cast(aLiteral)); + } + + template + static void LogValue(const Subject* aSubject, + DDLogClass aClass, + const char* aLabel, + const char (&aLiteral)[N]) + { + EagerLogValue(aSubject, aClass, aLabel, static_cast(aLiteral)); + } + + // Same as LogValue above, but needed to be seen by DDLOG... macros. + template + static void EagerLogValue(const char* aSubjectTypeName, + const void* aSubjectPointer, + DDLogClass aClass, + const char* aLabel, + const char (&aLiteral)[N]) + { + EagerLogValue(aSubjectTypeName, + aSubjectPointer, + aClass, + aLabel, + static_cast(aLiteral)); + } + + template + static void EagerLogValue(const Subject* aSubject, + DDLogClass aClass, + const char* aLabel, + const char (&aLiteral)[N]) + { + EagerLogValue(aSubject, aClass, aLabel, static_cast(aLiteral)); + } + + template + static void EagerLogPrintf(const char* aSubjectTypeName, + const void* aSubjectPointer, + DDLogClass aClass, + const char* aLabel, + const char* aFormat, + Args&&... aArgs) + { + Log(aSubjectTypeName, + aSubjectPointer, + aClass, + aLabel, + DDLogValue{ + nsCString{ nsPrintfCString(aFormat, Forward(aArgs)...) } }); + } + + template + static void EagerLogPrintf(const Subject* aSubject, + DDLogClass aClass, + const char* aLabel, + const char* aFormat, + Args&&... aArgs) + { + EagerLogPrintf(DDLoggedTypeTraits::Name(), + aSubject, + aClass, + aLabel, + aFormat, + Forward(aArgs)...); + } + + // Special logging functions. Consider using DecoderDoctorLifeLogger to + // automatically capture constructions & destructions. + + static void LogConstruction(const char* aSubjectTypeName, + const void* aSubjectPointer) + { + Log(aSubjectTypeName, + aSubjectPointer, + DDLogClass::_Construction, + "", + DDLogValue{ DDNoValue{} }); + } + + static void LogConstructionAndBase(const char* aSubjectTypeName, + const void* aSubjectPointer, + const char* aBaseTypeName, + const void* aBasePointer) + { + Log(aSubjectTypeName, + aSubjectPointer, + DDLogClass::_DerivedConstruction, + "", + DDLogValue{ DDLogObject{ aBaseTypeName, aBasePointer } }); + } + + template + static void LogConstructionAndBase(const char* aSubjectTypeName, + const void* aSubjectPointer, + const B* aBase) + { + Log(aSubjectTypeName, + aSubjectPointer, + DDLogClass::_DerivedConstruction, + "", + DDLogValue{ DDLogObject{ DDLoggedTypeTraits::Name(), aBase } }); + } + + template + static void LogConstruction(const Subject* aSubject) + { + using Traits = DDLoggedTypeTraits; + if (!Traits::HasBase::value) { + Log(DDLoggedTypeTraits::Name(), + aSubject, + DDLogClass::_Construction, + "", + DDLogValue{ DDNoValue{} }); + } else { + Log(DDLoggedTypeTraits::Name(), + aSubject, + DDLogClass::_DerivedConstruction, + "", + DDLogValue{ DDLogObject{ + DDLoggedTypeTraits::Name(), + static_cast(aSubject) } }); + } + } + + static void LogDestruction(const char* aSubjectTypeName, + const void* aSubjectPointer) + { + Log(aSubjectTypeName, + aSubjectPointer, + DDLogClass::_Destruction, + "", + DDLogValue{ DDNoValue{} }); + } + + template + static void LogDestruction(const Subject* aSubject) + { + Log(DDLoggedTypeTraits::Name(), + aSubject, + DDLogClass::_Destruction, + "", + DDLogValue{ DDNoValue{} }); + } + + template + static void LinkParentAndChild(const P* aParent, + const char* aLinkName, + const C* aChild) + { + if (aChild) { + Log(DDLoggedTypeTraits

::Name(), + aParent, + DDLogClass::_Link, + aLinkName, + DDLogValue{ DDLogObject{ DDLoggedTypeTraits::Name(), aChild } }); + } + } + + template + static void LinkParentAndChild(const char* aParentTypeName, + const void* aParentPointer, + const char* aLinkName, + const C* aChild) + { + if (aChild) { + Log(aParentTypeName, + aParentPointer, + DDLogClass::_Link, + aLinkName, + DDLogValue{ DDLogObject{ DDLoggedTypeTraits::Name(), aChild } }); + } + } + + template + static void LinkParentAndChild(const P* aParent, + const char* aLinkName, + const char* aChildTypeName, + const void* aChildPointer) + { + if (aChildPointer) { + Log(DDLoggedTypeTraits

::Name(), + aParent, + DDLogClass::_Link, + aLinkName, + DDLogValue{ DDLogObject{ aChildTypeName, aChildPointer } }); + } + } + + template + static void UnlinkParentAndChild(const char* aParentTypeName, + const void* aParentPointer, + const C* aChild) + { + if (aChild) { + Log(aParentTypeName, + aParentPointer, + DDLogClass::_Unlink, + "", + DDLogValue{ DDLogObject{ DDLoggedTypeTraits::Name(), aChild } }); + } + } + + template + static void UnlinkParentAndChild(const P* aParent, const C* aChild) + { + if (aChild) { + Log(DDLoggedTypeTraits

::Name(), + aParent, + DDLogClass::_Unlink, + "", + DDLogValue{ DDLogObject{ DDLoggedTypeTraits::Name(), aChild } }); + } + } + + // Retrieval functions. + + // Enable logging, if not done already. No effect otherwise. + static void EnableLogging(); + + using LogMessagesPromise = + MozPromise; + + // Retrieve all messages related to a given HTMLMediaElement object. + // This call will trigger a processing run (to ensure the most recent data + // will be returned), and the returned promise will be resolved with all + // relevant log messages and object lifetimes in a JSON string. + // The first call will enable logging, until shutdown. + static RefPtr RetrieveMessages( + const dom::HTMLMediaElement* aMediaElement); + +private: + // If logging is not enabled yet, initiate it, return true. + // If logging has been shutdown, don't start it, return false. + // Otherwise return true. + static bool EnsureLogIsEnabled(); + + // Note that this call may block while the state is scEnabling; + // set aDontBlock to true to avoid blocking, most importantly when the + // caller is the one doing the enabling, this would cause an endless loop. + static void PanicInternal(const char* aReason, bool aDontBlock); + + static void Log(const char* aSubjectTypeName, + const void* aSubjectPointer, + DDLogClass aClass, + const char* aLabel, + DDLogValue&& aValue); + + using LogState = int; + // Currently disabled, may be enabled on request. + static constexpr LogState scDisabled = 0; + // Currently enabled (logging happens), may be shutdown. + static constexpr LogState scEnabled = 1; + // Still disabled, but one thread is working on enabling it, nobody else + // should interfere during this time. + static constexpr LogState scEnabling = 2; + // Shutdown, cannot be re-enabled. + static constexpr LogState scShutdown = 3; + // Current state. + static Atomic sLogState; + + // If non-null, reason for an abnormal shutdown. + static const char* sShutdownReason; +}; + +// Base class to automatically record a class lifetime. Usage: +// class SomeClass : public DecoderDoctorLifeLogger +// { +// ... +template +class DecoderDoctorLifeLogger +{ +public: + DecoderDoctorLifeLogger() + { + DecoderDoctorLogger::LogConstruction(static_cast(this)); + } + ~DecoderDoctorLifeLogger() + { + DecoderDoctorLogger::LogDestruction(static_cast(this)); + } +}; + +// Macros to help lazily-evaluate arguments, only after we have checked that +// logging is enabled. + +// Log a single value; see DDLogValue for allowed types. +#define DDLOG(_class, _label, _arg) \ + do { \ + if (DecoderDoctorLogger::IsDDLoggingEnabled()) { \ + DecoderDoctorLogger::EagerLogValue(this, _class, _label, _arg); \ + } \ + } while (0) +// Log a single value, with an EXplicit `this`. +#define DDLOGEX(_this, _class, _label, _arg) \ + do { \ + if (DecoderDoctorLogger::IsDDLoggingEnabled()) { \ + DecoderDoctorLogger::EagerLogValue(_this, _class, _label, _arg); \ + } \ + } while (0) +// Log a single value, with EXplicit type name and `this`. +#define DDLOGEX2(_typename, _this, _class, _label, _arg) \ + do { \ + if (DecoderDoctorLogger::IsDDLoggingEnabled()) { \ + DecoderDoctorLogger::EagerLogValue( \ + _typename, _this, _class, _label, _arg); \ + } \ + } while (0) + +#ifdef DEBUG +// Do a printf format check in DEBUG, with the downside that side-effects (from +// evaluating the arguments) may happen twice! Who would do that anyway? +static void inline MOZ_FORMAT_PRINTF(1, 2) DDLOGPRCheck(const char*, ...) {} +#define DDLOGPR_CHECK(_fmt, ...) DDLOGPRCheck(_fmt, __VA_ARGS__) +#else +#define DDLOGPR_CHECK(_fmt, ...) +#endif + +// Log a printf'd string. Discouraged, please try using DDLOG instead. +#define DDLOGPR(_class, _label, _format, ...) \ + do { \ + if (DecoderDoctorLogger::IsDDLoggingEnabled()) { \ + DDLOGPR_CHECK(_format, __VA_ARGS__); \ + DecoderDoctorLogger::EagerLogPrintf( \ + this, _class, _label, _format, __VA_ARGS__); \ + } \ + } while (0) + +// Link a child object. +#define DDLINKCHILD(...) \ + do { \ + if (DecoderDoctorLogger::IsDDLoggingEnabled()) { \ + DecoderDoctorLogger::LinkParentAndChild(this, __VA_ARGS__); \ + } \ + } while (0) + +// Unlink a child object. +#define DDUNLINKCHILD(...) \ + do { \ + if (DecoderDoctorLogger::IsDDLoggingEnabled()) { \ + DecoderDoctorLogger::UnlinkParentAndChild(this, __VA_ARGS__); \ + } \ + } while (0) + +} // namespace mozilla + +#endif // DecoderDoctorLogger_h_ diff --git a/dom/media/doctor/moz.build b/dom/media/doctor/moz.build index a2a149aa2eaa..3e3097dfda3c 100644 --- a/dom/media/doctor/moz.build +++ b/dom/media/doctor/moz.build @@ -9,11 +9,27 @@ TEST_DIRS += [ ] EXPORTS += [ + 'DDLogClass.h', + 'DDLoggedTypeTraits.h', + 'DDLogObject.h', + 'DDLogValue.h', 'DecoderDoctorDiagnostics.h', + 'DecoderDoctorLogger.h', ] UNIFIED_SOURCES += [ + 'DDLifetime.cpp', + 'DDLifetimes.cpp', + 'DDLogClass.cpp', + 'DDLogMessage.cpp', + 'DDLogObject.cpp', + 'DDLogUtils.cpp', + 'DDLogValue.cpp', + 'DDMediaLog.cpp', + 'DDMediaLogs.cpp', + 'DDTimeStamp.cpp', 'DecoderDoctorDiagnostics.cpp', + 'DecoderDoctorLogger.cpp', ] FINAL_LIBRARY = 'xul' From 8f5500e263b5623551823c693e4ae51f546121ad Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Sun, 8 Oct 2017 19:10:40 -0500 Subject: [PATCH 12/15] servo: Merge #18786 - Rename nsIAtom as nsAtom (from nnethercote:bug-1400460); r=froydnj Bug 1400459 devirtualized nsIAtom so that it is no longer a subclass of nsISupports. This means that nsAtom is now a better name for it than nsIAtom. This is the Servo-side PR for https://bugzilla.mozilla.org/show_bug.cgi?id=1400460. --- - [X] `./mach build -d` does not report any errors - [X] `./mach test-tidy` does not report any errors - [ ] These changes fix https://bugzilla.mozilla.org/show_bug.cgi?id=1400460 - [ ] There are tests for these changes OR - [ ] These changes do not require tests because testing is on the Gecko side. Source-Repo: https://github.com/servo/servo Source-Revision: 715fc9cea6ed4ad22772c6d20136eac66cfe275c --HG-- extra : subtree_source : https%3A//hg.mozilla.org/projects/converted-servo-linear extra : subtree_revision : c3c028c08f605db5000531493cec20c3f427eeac --- .../style/gecko/generated/atom_macro.rs | 25004 ++++++++-------- .../style/gecko/generated/bindings.rs | 148 +- .../generated/pseudo_element_definition.rs | 2 +- .../style/gecko/generated/structs.rs | 254 +- .../gecko/pseudo_element_definition.mako.rs | 2 +- servo/components/style/gecko/regen_atoms.py | 10 +- .../style/gecko/snapshot_helpers.rs | 12 +- servo/components/style/gecko/wrapper.rs | 6 +- .../style/gecko_string_cache/mod.rs | 34 +- .../style/gecko_string_cache/namespace.rs | 4 +- .../components/style/properties/gecko.mako.rs | 8 +- servo/ports/geckolib/glue.rs | 20 +- 12 files changed, 12752 insertions(+), 12752 deletions(-) diff --git a/servo/components/style/gecko/generated/atom_macro.rs b/servo/components/style/gecko/generated/atom_macro.rs index 85889db88b9b..425cd5fcfd1a 100644 --- a/servo/components/style/gecko/generated/atom_macro.rs +++ b/servo/components/style/gecko/generated/atom_macro.rs @@ -4,7 +4,7 @@ /* Autogenerated file created by components/style/binding_tools/regen_atoms.py, DO NOT EDIT DIRECTLY */ -use gecko_bindings::structs::nsIAtom; +use gecko_bindings::structs::nsAtom; use string_cache::Atom; pub enum nsICSSPseudoElement {} @@ -12,7 +12,7 @@ pub enum nsICSSPseudoElement {} pub enum nsICSSAnonBoxPseudo {} #[inline(always)] -pub unsafe fn atom_from_static(ptr: *mut nsIAtom) -> Atom { +pub unsafe fn atom_from_static(ptr: *mut nsAtom) -> Atom { Atom::from_static(ptr) } @@ -21,5005 +21,5005 @@ cfg_if! { if #[cfg(not(target_env = "msvc"))] { extern { #[link_name = "_ZN9nsGkAtoms6_emptyE"] - pub static nsGkAtoms__empty: *mut nsIAtom; + pub static nsGkAtoms__empty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3mozE"] - pub static nsGkAtoms_moz: *mut nsIAtom; + pub static nsGkAtoms_moz: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12mozframetypeE"] - pub static nsGkAtoms_mozframetype: *mut nsIAtom; + pub static nsGkAtoms_mozframetype: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11_moz_absposE"] - pub static nsGkAtoms__moz_abspos: *mut nsIAtom; + pub static nsGkAtoms__moz_abspos: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14_moz_activatedE"] - pub static nsGkAtoms__moz_activated: *mut nsIAtom; + pub static nsGkAtoms__moz_activated: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14_moz_anonclassE"] - pub static nsGkAtoms__moz_anonclass: *mut nsIAtom; + pub static nsGkAtoms__moz_anonclass: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13_moz_resizingE"] - pub static nsGkAtoms__moz_resizing: *mut nsIAtom; + pub static nsGkAtoms__moz_resizing: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18mozallowfullscreenE"] - pub static nsGkAtoms_mozallowfullscreen: *mut nsIAtom; + pub static nsGkAtoms_mozallowfullscreen: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7moztypeE"] - pub static nsGkAtoms_moztype: *mut nsIAtom; + pub static nsGkAtoms_moztype: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8mozdirtyE"] - pub static nsGkAtoms_mozdirty: *mut nsIAtom; + pub static nsGkAtoms_mozdirty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms25mozdisallowselectionprintE"] - pub static nsGkAtoms_mozdisallowselectionprint: *mut nsIAtom; + pub static nsGkAtoms_mozdisallowselectionprint: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12mozdonotsendE"] - pub static nsGkAtoms_mozdonotsend: *mut nsIAtom; + pub static nsGkAtoms_mozdonotsend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18mozeditorbogusnodeE"] - pub static nsGkAtoms_mozeditorbogusnode: *mut nsIAtom; + pub static nsGkAtoms_mozeditorbogusnode: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms25mozgeneratedcontentbeforeE"] - pub static nsGkAtoms_mozgeneratedcontentbefore: *mut nsIAtom; + pub static nsGkAtoms_mozgeneratedcontentbefore: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24mozgeneratedcontentafterE"] - pub static nsGkAtoms_mozgeneratedcontentafter: *mut nsIAtom; + pub static nsGkAtoms_mozgeneratedcontentafter: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24mozgeneratedcontentimageE"] - pub static nsGkAtoms_mozgeneratedcontentimage: *mut nsIAtom; + pub static nsGkAtoms_mozgeneratedcontentimage: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8mozquoteE"] - pub static nsGkAtoms_mozquote: *mut nsIAtom; + pub static nsGkAtoms_mozquote: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12mozsignatureE"] - pub static nsGkAtoms_mozsignature: *mut nsIAtom; + pub static nsGkAtoms_mozsignature: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13_moz_is_glyphE"] - pub static nsGkAtoms__moz_is_glyph: *mut nsIAtom; + pub static nsGkAtoms__moz_is_glyph: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18_moz_original_sizeE"] - pub static nsGkAtoms__moz_original_size: *mut nsIAtom; + pub static nsGkAtoms__moz_original_size: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11_moz_targetE"] - pub static nsGkAtoms__moz_target: *mut nsIAtom; + pub static nsGkAtoms__moz_target: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10menuactiveE"] - pub static nsGkAtoms_menuactive: *mut nsIAtom; + pub static nsGkAtoms_menuactive: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13_poundDefaultE"] - pub static nsGkAtoms__poundDefault: *mut nsIAtom; + pub static nsGkAtoms__poundDefault: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9_asteriskE"] - pub static nsGkAtoms__asterisk: *mut nsIAtom; + pub static nsGkAtoms__asterisk: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms1aE"] - pub static nsGkAtoms_a: *mut nsIAtom; + pub static nsGkAtoms_a: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4abbrE"] - pub static nsGkAtoms_abbr: *mut nsIAtom; + pub static nsGkAtoms_abbr: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5abortE"] - pub static nsGkAtoms_abort: *mut nsIAtom; + pub static nsGkAtoms_abort: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5aboveE"] - pub static nsGkAtoms_above: *mut nsIAtom; + pub static nsGkAtoms_above: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9acceltextE"] - pub static nsGkAtoms_acceltext: *mut nsIAtom; + pub static nsGkAtoms_acceltext: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6acceptE"] - pub static nsGkAtoms_accept: *mut nsIAtom; + pub static nsGkAtoms_accept: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13acceptcharsetE"] - pub static nsGkAtoms_acceptcharset: *mut nsIAtom; + pub static nsGkAtoms_acceptcharset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9accesskeyE"] - pub static nsGkAtoms_accesskey: *mut nsIAtom; + pub static nsGkAtoms_accesskey: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7acronymE"] - pub static nsGkAtoms_acronym: *mut nsIAtom; + pub static nsGkAtoms_acronym: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6actionE"] - pub static nsGkAtoms_action: *mut nsIAtom; + pub static nsGkAtoms_action: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6activeE"] - pub static nsGkAtoms_active: *mut nsIAtom; + pub static nsGkAtoms_active: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19activetitlebarcolorE"] - pub static nsGkAtoms_activetitlebarcolor: *mut nsIAtom; + pub static nsGkAtoms_activetitlebarcolor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13activateontabE"] - pub static nsGkAtoms_activateontab: *mut nsIAtom; + pub static nsGkAtoms_activateontab: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7actuateE"] - pub static nsGkAtoms_actuate: *mut nsIAtom; + pub static nsGkAtoms_actuate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7addressE"] - pub static nsGkAtoms_address: *mut nsIAtom; + pub static nsGkAtoms_address: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5afterE"] - pub static nsGkAtoms_after: *mut nsIAtom; + pub static nsGkAtoms_after: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9after_endE"] - pub static nsGkAtoms_after_end: *mut nsIAtom; + pub static nsGkAtoms_after_end: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11after_startE"] - pub static nsGkAtoms_after_start: *mut nsIAtom; + pub static nsGkAtoms_after_start: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5alignE"] - pub static nsGkAtoms_align: *mut nsIAtom; + pub static nsGkAtoms_align: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5alinkE"] - pub static nsGkAtoms_alink: *mut nsIAtom; + pub static nsGkAtoms_alink: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3allE"] - pub static nsGkAtoms_all: *mut nsIAtom; + pub static nsGkAtoms_all: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9allowdirsE"] - pub static nsGkAtoms_allowdirs: *mut nsIAtom; + pub static nsGkAtoms_allowdirs: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11alloweventsE"] - pub static nsGkAtoms_allowevents: *mut nsIAtom; + pub static nsGkAtoms_allowevents: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23allownegativeassertionsE"] - pub static nsGkAtoms_allownegativeassertions: *mut nsIAtom; + pub static nsGkAtoms_allownegativeassertions: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10allowformsE"] - pub static nsGkAtoms_allowforms: *mut nsIAtom; + pub static nsGkAtoms_allowforms: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15allowfullscreenE"] - pub static nsGkAtoms_allowfullscreen: *mut nsIAtom; + pub static nsGkAtoms_allowfullscreen: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11allowmodalsE"] - pub static nsGkAtoms_allowmodals: *mut nsIAtom; + pub static nsGkAtoms_allowmodals: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20alloworientationlockE"] - pub static nsGkAtoms_alloworientationlock: *mut nsIAtom; + pub static nsGkAtoms_alloworientationlock: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19allowpaymentrequestE"] - pub static nsGkAtoms_allowpaymentrequest: *mut nsIAtom; + pub static nsGkAtoms_allowpaymentrequest: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16allowpointerlockE"] - pub static nsGkAtoms_allowpointerlock: *mut nsIAtom; + pub static nsGkAtoms_allowpointerlock: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms26allowpopupstoescapesandboxE"] - pub static nsGkAtoms_allowpopupstoescapesandbox: *mut nsIAtom; + pub static nsGkAtoms_allowpopupstoescapesandbox: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11allowpopupsE"] - pub static nsGkAtoms_allowpopups: *mut nsIAtom; + pub static nsGkAtoms_allowpopups: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17allowpresentationE"] - pub static nsGkAtoms_allowpresentation: *mut nsIAtom; + pub static nsGkAtoms_allowpresentation: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15allowsameoriginE"] - pub static nsGkAtoms_allowsameorigin: *mut nsIAtom; + pub static nsGkAtoms_allowsameorigin: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12allowscriptsE"] - pub static nsGkAtoms_allowscripts: *mut nsIAtom; + pub static nsGkAtoms_allowscripts: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18allowtopnavigationE"] - pub static nsGkAtoms_allowtopnavigation: *mut nsIAtom; + pub static nsGkAtoms_allowtopnavigation: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14allowuntrustedE"] - pub static nsGkAtoms_allowuntrusted: *mut nsIAtom; + pub static nsGkAtoms_allowuntrusted: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3altE"] - pub static nsGkAtoms_alt: *mut nsIAtom; + pub static nsGkAtoms_alt: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9alternateE"] - pub static nsGkAtoms_alternate: *mut nsIAtom; + pub static nsGkAtoms_alternate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6alwaysE"] - pub static nsGkAtoms_always: *mut nsIAtom; + pub static nsGkAtoms_always: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8ancestorE"] - pub static nsGkAtoms_ancestor: *mut nsIAtom; + pub static nsGkAtoms_ancestor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14ancestorOrSelfE"] - pub static nsGkAtoms_ancestorOrSelf: *mut nsIAtom; + pub static nsGkAtoms_ancestorOrSelf: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6anchorE"] - pub static nsGkAtoms_anchor: *mut nsIAtom; + pub static nsGkAtoms_anchor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4_andE"] - pub static nsGkAtoms__and: *mut nsIAtom; + pub static nsGkAtoms__and: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10animationsE"] - pub static nsGkAtoms_animations: *mut nsIAtom; + pub static nsGkAtoms_animations: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6anonidE"] - pub static nsGkAtoms_anonid: *mut nsIAtom; + pub static nsGkAtoms_anonid: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12anonlocationE"] - pub static nsGkAtoms_anonlocation: *mut nsIAtom; + pub static nsGkAtoms_anonlocation: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3anyE"] - pub static nsGkAtoms_any: *mut nsIAtom; + pub static nsGkAtoms_any: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6appletE"] - pub static nsGkAtoms_applet: *mut nsIAtom; + pub static nsGkAtoms_applet: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12applyImportsE"] - pub static nsGkAtoms_applyImports: *mut nsIAtom; + pub static nsGkAtoms_applyImports: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14applyTemplatesE"] - pub static nsGkAtoms_applyTemplates: *mut nsIAtom; + pub static nsGkAtoms_applyTemplates: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7archiveE"] - pub static nsGkAtoms_archive: *mut nsIAtom; + pub static nsGkAtoms_archive: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4areaE"] - pub static nsGkAtoms_area: *mut nsIAtom; + pub static nsGkAtoms_area: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21aria_activedescendantE"] - pub static nsGkAtoms_aria_activedescendant: *mut nsIAtom; + pub static nsGkAtoms_aria_activedescendant: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11aria_atomicE"] - pub static nsGkAtoms_aria_atomic: *mut nsIAtom; + pub static nsGkAtoms_aria_atomic: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17aria_autocompleteE"] - pub static nsGkAtoms_aria_autocomplete: *mut nsIAtom; + pub static nsGkAtoms_aria_autocomplete: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9aria_busyE"] - pub static nsGkAtoms_aria_busy: *mut nsIAtom; + pub static nsGkAtoms_aria_busy: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12aria_checkedE"] - pub static nsGkAtoms_aria_checked: *mut nsIAtom; + pub static nsGkAtoms_aria_checked: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13aria_controlsE"] - pub static nsGkAtoms_aria_controls: *mut nsIAtom; + pub static nsGkAtoms_aria_controls: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12aria_currentE"] - pub static nsGkAtoms_aria_current: *mut nsIAtom; + pub static nsGkAtoms_aria_current: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16aria_describedbyE"] - pub static nsGkAtoms_aria_describedby: *mut nsIAtom; + pub static nsGkAtoms_aria_describedby: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13aria_disabledE"] - pub static nsGkAtoms_aria_disabled: *mut nsIAtom; + pub static nsGkAtoms_aria_disabled: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15aria_dropeffectE"] - pub static nsGkAtoms_aria_dropeffect: *mut nsIAtom; + pub static nsGkAtoms_aria_dropeffect: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13aria_expandedE"] - pub static nsGkAtoms_aria_expanded: *mut nsIAtom; + pub static nsGkAtoms_aria_expanded: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11aria_flowtoE"] - pub static nsGkAtoms_aria_flowto: *mut nsIAtom; + pub static nsGkAtoms_aria_flowto: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13aria_haspopupE"] - pub static nsGkAtoms_aria_haspopup: *mut nsIAtom; + pub static nsGkAtoms_aria_haspopup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11aria_hiddenE"] - pub static nsGkAtoms_aria_hidden: *mut nsIAtom; + pub static nsGkAtoms_aria_hidden: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12aria_invalidE"] - pub static nsGkAtoms_aria_invalid: *mut nsIAtom; + pub static nsGkAtoms_aria_invalid: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15aria_labelledbyE"] - pub static nsGkAtoms_aria_labelledby: *mut nsIAtom; + pub static nsGkAtoms_aria_labelledby: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10aria_levelE"] - pub static nsGkAtoms_aria_level: *mut nsIAtom; + pub static nsGkAtoms_aria_level: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9aria_liveE"] - pub static nsGkAtoms_aria_live: *mut nsIAtom; + pub static nsGkAtoms_aria_live: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14aria_multilineE"] - pub static nsGkAtoms_aria_multiline: *mut nsIAtom; + pub static nsGkAtoms_aria_multiline: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20aria_multiselectableE"] - pub static nsGkAtoms_aria_multiselectable: *mut nsIAtom; + pub static nsGkAtoms_aria_multiselectable: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9aria_ownsE"] - pub static nsGkAtoms_aria_owns: *mut nsIAtom; + pub static nsGkAtoms_aria_owns: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13aria_posinsetE"] - pub static nsGkAtoms_aria_posinset: *mut nsIAtom; + pub static nsGkAtoms_aria_posinset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12aria_pressedE"] - pub static nsGkAtoms_aria_pressed: *mut nsIAtom; + pub static nsGkAtoms_aria_pressed: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13aria_readonlyE"] - pub static nsGkAtoms_aria_readonly: *mut nsIAtom; + pub static nsGkAtoms_aria_readonly: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13aria_relevantE"] - pub static nsGkAtoms_aria_relevant: *mut nsIAtom; + pub static nsGkAtoms_aria_relevant: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13aria_requiredE"] - pub static nsGkAtoms_aria_required: *mut nsIAtom; + pub static nsGkAtoms_aria_required: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13aria_selectedE"] - pub static nsGkAtoms_aria_selected: *mut nsIAtom; + pub static nsGkAtoms_aria_selected: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12aria_setsizeE"] - pub static nsGkAtoms_aria_setsize: *mut nsIAtom; + pub static nsGkAtoms_aria_setsize: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9aria_sortE"] - pub static nsGkAtoms_aria_sort: *mut nsIAtom; + pub static nsGkAtoms_aria_sort: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13aria_valuemaxE"] - pub static nsGkAtoms_aria_valuemax: *mut nsIAtom; + pub static nsGkAtoms_aria_valuemax: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13aria_valueminE"] - pub static nsGkAtoms_aria_valuemin: *mut nsIAtom; + pub static nsGkAtoms_aria_valuemin: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13aria_valuenowE"] - pub static nsGkAtoms_aria_valuenow: *mut nsIAtom; + pub static nsGkAtoms_aria_valuenow: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5arrowE"] - pub static nsGkAtoms_arrow: *mut nsIAtom; + pub static nsGkAtoms_arrow: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7articleE"] - pub static nsGkAtoms_article: *mut nsIAtom; + pub static nsGkAtoms_article: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2asE"] - pub static nsGkAtoms_as: *mut nsIAtom; + pub static nsGkAtoms_as: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9ascendingE"] - pub static nsGkAtoms_ascending: *mut nsIAtom; + pub static nsGkAtoms_ascending: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5asideE"] - pub static nsGkAtoms_aside: *mut nsIAtom; + pub static nsGkAtoms_aside: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11aspectRatioE"] - pub static nsGkAtoms_aspectRatio: *mut nsIAtom; + pub static nsGkAtoms_aspectRatio: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6assignE"] - pub static nsGkAtoms_assign: *mut nsIAtom; + pub static nsGkAtoms_assign: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5asyncE"] - pub static nsGkAtoms_async: *mut nsIAtom; + pub static nsGkAtoms_async: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9attributeE"] - pub static nsGkAtoms_attribute: *mut nsIAtom; + pub static nsGkAtoms_attribute: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10attributesE"] - pub static nsGkAtoms_attributes: *mut nsIAtom; + pub static nsGkAtoms_attributes: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12attributeSetE"] - pub static nsGkAtoms_attributeSet: *mut nsIAtom; + pub static nsGkAtoms_attributeSet: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5auralE"] - pub static nsGkAtoms_aural: *mut nsIAtom; + pub static nsGkAtoms_aural: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5_autoE"] - pub static nsGkAtoms__auto: *mut nsIAtom; + pub static nsGkAtoms__auto: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9autocheckE"] - pub static nsGkAtoms_autocheck: *mut nsIAtom; + pub static nsGkAtoms_autocheck: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12autocompleteE"] - pub static nsGkAtoms_autocomplete: *mut nsIAtom; + pub static nsGkAtoms_autocomplete: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9autofocusE"] - pub static nsGkAtoms_autofocus: *mut nsIAtom; + pub static nsGkAtoms_autofocus: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8autoplayE"] - pub static nsGkAtoms_autoplay: *mut nsIAtom; + pub static nsGkAtoms_autoplay: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16autorepeatbuttonE"] - pub static nsGkAtoms_autorepeatbutton: *mut nsIAtom; + pub static nsGkAtoms_autorepeatbutton: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4axisE"] - pub static nsGkAtoms_axis: *mut nsIAtom; + pub static nsGkAtoms_axis: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms1bE"] - pub static nsGkAtoms_b: *mut nsIAtom; + pub static nsGkAtoms_b: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10backgroundE"] - pub static nsGkAtoms_background: *mut nsIAtom; + pub static nsGkAtoms_background: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4baseE"] - pub static nsGkAtoms_base: *mut nsIAtom; + pub static nsGkAtoms_base: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8basefontE"] - pub static nsGkAtoms_basefont: *mut nsIAtom; + pub static nsGkAtoms_basefont: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8baselineE"] - pub static nsGkAtoms_baseline: *mut nsIAtom; + pub static nsGkAtoms_baseline: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3bdiE"] - pub static nsGkAtoms_bdi: *mut nsIAtom; + pub static nsGkAtoms_bdi: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3bdoE"] - pub static nsGkAtoms_bdo: *mut nsIAtom; + pub static nsGkAtoms_bdo: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6beforeE"] - pub static nsGkAtoms_before: *mut nsIAtom; + pub static nsGkAtoms_before: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10before_endE"] - pub static nsGkAtoms_before_end: *mut nsIAtom; + pub static nsGkAtoms_before_end: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12before_startE"] - pub static nsGkAtoms_before_start: *mut nsIAtom; + pub static nsGkAtoms_before_start: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5belowE"] - pub static nsGkAtoms_below: *mut nsIAtom; + pub static nsGkAtoms_below: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7bgcolorE"] - pub static nsGkAtoms_bgcolor: *mut nsIAtom; + pub static nsGkAtoms_bgcolor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7bgsoundE"] - pub static nsGkAtoms_bgsound: *mut nsIAtom; + pub static nsGkAtoms_bgsound: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3bigE"] - pub static nsGkAtoms_big: *mut nsIAtom; + pub static nsGkAtoms_big: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7bindingE"] - pub static nsGkAtoms_binding: *mut nsIAtom; + pub static nsGkAtoms_binding: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8bindingsE"] - pub static nsGkAtoms_bindings: *mut nsIAtom; + pub static nsGkAtoms_bindings: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms22bindToUntrustedContentE"] - pub static nsGkAtoms_bindToUntrustedContent: *mut nsIAtom; + pub static nsGkAtoms_bindToUntrustedContent: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8blankrowE"] - pub static nsGkAtoms_blankrow: *mut nsIAtom; + pub static nsGkAtoms_blankrow: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5blockE"] - pub static nsGkAtoms_block: *mut nsIAtom; + pub static nsGkAtoms_block: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10blockquoteE"] - pub static nsGkAtoms_blockquote: *mut nsIAtom; + pub static nsGkAtoms_blockquote: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4blurE"] - pub static nsGkAtoms_blur: *mut nsIAtom; + pub static nsGkAtoms_blur: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4bodyE"] - pub static nsGkAtoms_body: *mut nsIAtom; + pub static nsGkAtoms_body: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7booleanE"] - pub static nsGkAtoms_boolean: *mut nsIAtom; + pub static nsGkAtoms_boolean: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6borderE"] - pub static nsGkAtoms_border: *mut nsIAtom; + pub static nsGkAtoms_border: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11bordercolorE"] - pub static nsGkAtoms_bordercolor: *mut nsIAtom; + pub static nsGkAtoms_bordercolor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4bothE"] - pub static nsGkAtoms_both: *mut nsIAtom; + pub static nsGkAtoms_both: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6bottomE"] - pub static nsGkAtoms_bottom: *mut nsIAtom; + pub static nsGkAtoms_bottom: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9bottomendE"] - pub static nsGkAtoms_bottomend: *mut nsIAtom; + pub static nsGkAtoms_bottomend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11bottomstartE"] - pub static nsGkAtoms_bottomstart: *mut nsIAtom; + pub static nsGkAtoms_bottomstart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10bottomleftE"] - pub static nsGkAtoms_bottomleft: *mut nsIAtom; + pub static nsGkAtoms_bottomleft: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12bottommarginE"] - pub static nsGkAtoms_bottommargin: *mut nsIAtom; + pub static nsGkAtoms_bottommargin: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13bottompaddingE"] - pub static nsGkAtoms_bottompadding: *mut nsIAtom; + pub static nsGkAtoms_bottompadding: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11bottomrightE"] - pub static nsGkAtoms_bottomright: *mut nsIAtom; + pub static nsGkAtoms_bottomright: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3boxE"] - pub static nsGkAtoms_box: *mut nsIAtom; + pub static nsGkAtoms_box: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2brE"] - pub static nsGkAtoms_br: *mut nsIAtom; + pub static nsGkAtoms_br: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7brailleE"] - pub static nsGkAtoms_braille: *mut nsIAtom; + pub static nsGkAtoms_braille: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9broadcastE"] - pub static nsGkAtoms_broadcast: *mut nsIAtom; + pub static nsGkAtoms_broadcast: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11broadcasterE"] - pub static nsGkAtoms_broadcaster: *mut nsIAtom; + pub static nsGkAtoms_broadcaster: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14broadcastersetE"] - pub static nsGkAtoms_broadcasterset: *mut nsIAtom; + pub static nsGkAtoms_broadcasterset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7browserE"] - pub static nsGkAtoms_browser: *mut nsIAtom; + pub static nsGkAtoms_browser: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10mozbrowserE"] - pub static nsGkAtoms_mozbrowser: *mut nsIAtom; + pub static nsGkAtoms_mozbrowser: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13bulletinboardE"] - pub static nsGkAtoms_bulletinboard: *mut nsIAtom; + pub static nsGkAtoms_bulletinboard: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6buttonE"] - pub static nsGkAtoms_button: *mut nsIAtom; + pub static nsGkAtoms_button: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24brighttitlebarforegroundE"] - pub static nsGkAtoms_brighttitlebarforeground: *mut nsIAtom; + pub static nsGkAtoms_brighttitlebarforeground: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12callTemplateE"] - pub static nsGkAtoms_callTemplate: *mut nsIAtom; + pub static nsGkAtoms_callTemplate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6cancelE"] - pub static nsGkAtoms_cancel: *mut nsIAtom; + pub static nsGkAtoms_cancel: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6canvasE"] - pub static nsGkAtoms_canvas: *mut nsIAtom; + pub static nsGkAtoms_canvas: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7captionE"] - pub static nsGkAtoms_caption: *mut nsIAtom; + pub static nsGkAtoms_caption: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7captureE"] - pub static nsGkAtoms_capture: *mut nsIAtom; + pub static nsGkAtoms_capture: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9caseOrderE"] - pub static nsGkAtoms_caseOrder: *mut nsIAtom; + pub static nsGkAtoms_caseOrder: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20cdataSectionElementsE"] - pub static nsGkAtoms_cdataSectionElements: *mut nsIAtom; + pub static nsGkAtoms_cdataSectionElements: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7ceilingE"] - pub static nsGkAtoms_ceiling: *mut nsIAtom; + pub static nsGkAtoms_ceiling: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4cellE"] - pub static nsGkAtoms_cell: *mut nsIAtom; + pub static nsGkAtoms_cell: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11cellpaddingE"] - pub static nsGkAtoms_cellpadding: *mut nsIAtom; + pub static nsGkAtoms_cellpadding: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11cellspacingE"] - pub static nsGkAtoms_cellspacing: *mut nsIAtom; + pub static nsGkAtoms_cellspacing: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6centerE"] - pub static nsGkAtoms_center: *mut nsIAtom; + pub static nsGkAtoms_center: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2chE"] - pub static nsGkAtoms_ch: *mut nsIAtom; + pub static nsGkAtoms_ch: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6changeE"] - pub static nsGkAtoms_change: *mut nsIAtom; + pub static nsGkAtoms_change: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5_charE"] - pub static nsGkAtoms__char: *mut nsIAtom; + pub static nsGkAtoms__char: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13characterDataE"] - pub static nsGkAtoms_characterData: *mut nsIAtom; + pub static nsGkAtoms_characterData: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8charcodeE"] - pub static nsGkAtoms_charcode: *mut nsIAtom; + pub static nsGkAtoms_charcode: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7charoffE"] - pub static nsGkAtoms_charoff: *mut nsIAtom; + pub static nsGkAtoms_charoff: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7charsetE"] - pub static nsGkAtoms_charset: *mut nsIAtom; + pub static nsGkAtoms_charset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8checkboxE"] - pub static nsGkAtoms_checkbox: *mut nsIAtom; + pub static nsGkAtoms_checkbox: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7checkedE"] - pub static nsGkAtoms_checked: *mut nsIAtom; + pub static nsGkAtoms_checked: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5childE"] - pub static nsGkAtoms_child: *mut nsIAtom; + pub static nsGkAtoms_child: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8childrenE"] - pub static nsGkAtoms_children: *mut nsIAtom; + pub static nsGkAtoms_children: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9childListE"] - pub static nsGkAtoms_childList: *mut nsIAtom; + pub static nsGkAtoms_childList: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6chooseE"] - pub static nsGkAtoms_choose: *mut nsIAtom; + pub static nsGkAtoms_choose: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12chromemarginE"] - pub static nsGkAtoms_chromemargin: *mut nsIAtom; + pub static nsGkAtoms_chromemargin: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17chromeOnlyContentE"] - pub static nsGkAtoms_chromeOnlyContent: *mut nsIAtom; + pub static nsGkAtoms_chromeOnlyContent: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24exposeToUntrustedContentE"] - pub static nsGkAtoms_exposeToUntrustedContent: *mut nsIAtom; + pub static nsGkAtoms_exposeToUntrustedContent: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4circE"] - pub static nsGkAtoms_circ: *mut nsIAtom; + pub static nsGkAtoms_circ: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6circleE"] - pub static nsGkAtoms_circle: *mut nsIAtom; + pub static nsGkAtoms_circle: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4citeE"] - pub static nsGkAtoms_cite: *mut nsIAtom; + pub static nsGkAtoms_cite: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10cjkDecimalE"] - pub static nsGkAtoms_cjkDecimal: *mut nsIAtom; + pub static nsGkAtoms_cjkDecimal: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6_classE"] - pub static nsGkAtoms__class: *mut nsIAtom; + pub static nsGkAtoms__class: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7classidE"] - pub static nsGkAtoms_classid: *mut nsIAtom; + pub static nsGkAtoms_classid: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5clearE"] - pub static nsGkAtoms_clear: *mut nsIAtom; + pub static nsGkAtoms_clear: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5clickE"] - pub static nsGkAtoms_click: *mut nsIAtom; + pub static nsGkAtoms_click: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10clickcountE"] - pub static nsGkAtoms_clickcount: *mut nsIAtom; + pub static nsGkAtoms_clickcount: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12clickthroughE"] - pub static nsGkAtoms_clickthrough: *mut nsIAtom; + pub static nsGkAtoms_clickthrough: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11movetoclickE"] - pub static nsGkAtoms_movetoclick: *mut nsIAtom; + pub static nsGkAtoms_movetoclick: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4clipE"] - pub static nsGkAtoms_clip: *mut nsIAtom; + pub static nsGkAtoms_clip: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5closeE"] - pub static nsGkAtoms_close: *mut nsIAtom; + pub static nsGkAtoms_close: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6closedE"] - pub static nsGkAtoms_closed: *mut nsIAtom; + pub static nsGkAtoms_closed: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9closemenuE"] - pub static nsGkAtoms_closemenu: *mut nsIAtom; + pub static nsGkAtoms_closemenu: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21coalesceduplicatearcsE"] - pub static nsGkAtoms_coalesceduplicatearcs: *mut nsIAtom; + pub static nsGkAtoms_coalesceduplicatearcs: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4codeE"] - pub static nsGkAtoms_code: *mut nsIAtom; + pub static nsGkAtoms_code: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8codebaseE"] - pub static nsGkAtoms_codebase: *mut nsIAtom; + pub static nsGkAtoms_codebase: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8codetypeE"] - pub static nsGkAtoms_codetype: *mut nsIAtom; + pub static nsGkAtoms_codetype: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3colE"] - pub static nsGkAtoms_col: *mut nsIAtom; + pub static nsGkAtoms_col: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8colgroupE"] - pub static nsGkAtoms_colgroup: *mut nsIAtom; + pub static nsGkAtoms_colgroup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8collapseE"] - pub static nsGkAtoms_collapse: *mut nsIAtom; + pub static nsGkAtoms_collapse: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9collapsedE"] - pub static nsGkAtoms_collapsed: *mut nsIAtom; + pub static nsGkAtoms_collapsed: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5colorE"] - pub static nsGkAtoms_color: *mut nsIAtom; + pub static nsGkAtoms_color: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10colorIndexE"] - pub static nsGkAtoms_colorIndex: *mut nsIAtom; + pub static nsGkAtoms_colorIndex: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4colsE"] - pub static nsGkAtoms_cols: *mut nsIAtom; + pub static nsGkAtoms_cols: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7colspanE"] - pub static nsGkAtoms_colspan: *mut nsIAtom; + pub static nsGkAtoms_colspan: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6columnE"] - pub static nsGkAtoms_column: *mut nsIAtom; + pub static nsGkAtoms_column: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7columnsE"] - pub static nsGkAtoms_columns: *mut nsIAtom; + pub static nsGkAtoms_columns: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8comboboxE"] - pub static nsGkAtoms_combobox: *mut nsIAtom; + pub static nsGkAtoms_combobox: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7commandE"] - pub static nsGkAtoms_command: *mut nsIAtom; + pub static nsGkAtoms_command: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8commandsE"] - pub static nsGkAtoms_commands: *mut nsIAtom; + pub static nsGkAtoms_commands: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10commandsetE"] - pub static nsGkAtoms_commandset: *mut nsIAtom; + pub static nsGkAtoms_commandset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13commandupdateE"] - pub static nsGkAtoms_commandupdate: *mut nsIAtom; + pub static nsGkAtoms_commandupdate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14commandupdaterE"] - pub static nsGkAtoms_commandupdater: *mut nsIAtom; + pub static nsGkAtoms_commandupdater: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7commentE"] - pub static nsGkAtoms_comment: *mut nsIAtom; + pub static nsGkAtoms_comment: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7compactE"] - pub static nsGkAtoms_compact: *mut nsIAtom; + pub static nsGkAtoms_compact: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6concatE"] - pub static nsGkAtoms_concat: *mut nsIAtom; + pub static nsGkAtoms_concat: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10conditionsE"] - pub static nsGkAtoms_conditions: *mut nsIAtom; + pub static nsGkAtoms_conditions: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11constructorE"] - pub static nsGkAtoms_constructor: *mut nsIAtom; + pub static nsGkAtoms_constructor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20consumeoutsideclicksE"] - pub static nsGkAtoms_consumeoutsideclicks: *mut nsIAtom; + pub static nsGkAtoms_consumeoutsideclicks: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9containerE"] - pub static nsGkAtoms_container: *mut nsIAtom; + pub static nsGkAtoms_container: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11containmentE"] - pub static nsGkAtoms_containment: *mut nsIAtom; + pub static nsGkAtoms_containment: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8containsE"] - pub static nsGkAtoms_contains: *mut nsIAtom; + pub static nsGkAtoms_contains: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7contentE"] - pub static nsGkAtoms_content: *mut nsIAtom; + pub static nsGkAtoms_content: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15contenteditableE"] - pub static nsGkAtoms_contenteditable: *mut nsIAtom; + pub static nsGkAtoms_contenteditable: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24headerContentDispositionE"] - pub static nsGkAtoms_headerContentDisposition: *mut nsIAtom; + pub static nsGkAtoms_headerContentDisposition: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21headerContentLanguageE"] - pub static nsGkAtoms_headerContentLanguage: *mut nsIAtom; + pub static nsGkAtoms_headerContentLanguage: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15contentLocationE"] - pub static nsGkAtoms_contentLocation: *mut nsIAtom; + pub static nsGkAtoms_contentLocation: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23headerContentScriptTypeE"] - pub static nsGkAtoms_headerContentScriptType: *mut nsIAtom; + pub static nsGkAtoms_headerContentScriptType: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms22headerContentStyleTypeE"] - pub static nsGkAtoms_headerContentStyleType: *mut nsIAtom; + pub static nsGkAtoms_headerContentStyleType: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17headerContentTypeE"] - pub static nsGkAtoms_headerContentType: *mut nsIAtom; + pub static nsGkAtoms_headerContentType: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13consumeanchorE"] - pub static nsGkAtoms_consumeanchor: *mut nsIAtom; + pub static nsGkAtoms_consumeanchor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7contextE"] - pub static nsGkAtoms_context: *mut nsIAtom; + pub static nsGkAtoms_context: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11contextmenuE"] - pub static nsGkAtoms_contextmenu: *mut nsIAtom; + pub static nsGkAtoms_contextmenu: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7controlE"] - pub static nsGkAtoms_control: *mut nsIAtom; + pub static nsGkAtoms_control: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8controlsE"] - pub static nsGkAtoms_controls: *mut nsIAtom; + pub static nsGkAtoms_controls: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6coordsE"] - pub static nsGkAtoms_coords: *mut nsIAtom; + pub static nsGkAtoms_coords: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4copyE"] - pub static nsGkAtoms_copy: *mut nsIAtom; + pub static nsGkAtoms_copy: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6copyOfE"] - pub static nsGkAtoms_copyOf: *mut nsIAtom; + pub static nsGkAtoms_copyOf: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5countE"] - pub static nsGkAtoms_count: *mut nsIAtom; + pub static nsGkAtoms_count: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4cropE"] - pub static nsGkAtoms_crop: *mut nsIAtom; + pub static nsGkAtoms_crop: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11crossoriginE"] - pub static nsGkAtoms_crossorigin: *mut nsIAtom; + pub static nsGkAtoms_crossorigin: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6curposE"] - pub static nsGkAtoms_curpos: *mut nsIAtom; + pub static nsGkAtoms_curpos: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7currentE"] - pub static nsGkAtoms_current: *mut nsIAtom; + pub static nsGkAtoms_current: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12cutoutregionE"] - pub static nsGkAtoms_cutoutregion: *mut nsIAtom; + pub static nsGkAtoms_cutoutregion: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6cyclerE"] - pub static nsGkAtoms_cycler: *mut nsIAtom; + pub static nsGkAtoms_cycler: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4dataE"] - pub static nsGkAtoms_data: *mut nsIAtom; + pub static nsGkAtoms_data: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8datalistE"] - pub static nsGkAtoms_datalist: *mut nsIAtom; + pub static nsGkAtoms_datalist: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8dataTypeE"] - pub static nsGkAtoms_dataType: *mut nsIAtom; + pub static nsGkAtoms_dataType: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8dateTimeE"] - pub static nsGkAtoms_dateTime: *mut nsIAtom; + pub static nsGkAtoms_dateTime: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11datasourcesE"] - pub static nsGkAtoms_datasources: *mut nsIAtom; + pub static nsGkAtoms_datasources: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8datetimeE"] - pub static nsGkAtoms_datetime: *mut nsIAtom; + pub static nsGkAtoms_datetime: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11datetimeboxE"] - pub static nsGkAtoms_datetimebox: *mut nsIAtom; + pub static nsGkAtoms_datetimebox: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8dblclickE"] - pub static nsGkAtoms_dblclick: *mut nsIAtom; + pub static nsGkAtoms_dblclick: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2ddE"] - pub static nsGkAtoms_dd: *mut nsIAtom; + pub static nsGkAtoms_dd: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5debugE"] - pub static nsGkAtoms_debug: *mut nsIAtom; + pub static nsGkAtoms_debug: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7decimalE"] - pub static nsGkAtoms_decimal: *mut nsIAtom; + pub static nsGkAtoms_decimal: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13decimalFormatE"] - pub static nsGkAtoms_decimalFormat: *mut nsIAtom; + pub static nsGkAtoms_decimalFormat: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16decimalSeparatorE"] - pub static nsGkAtoms_decimalSeparator: *mut nsIAtom; + pub static nsGkAtoms_decimalSeparator: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4deckE"] - pub static nsGkAtoms_deck: *mut nsIAtom; + pub static nsGkAtoms_deck: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7declareE"] - pub static nsGkAtoms_declare: *mut nsIAtom; + pub static nsGkAtoms_declare: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13decoderDoctorE"] - pub static nsGkAtoms_decoderDoctor: *mut nsIAtom; + pub static nsGkAtoms_decoderDoctor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9decrementE"] - pub static nsGkAtoms_decrement: *mut nsIAtom; + pub static nsGkAtoms_decrement: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8_defaultE"] - pub static nsGkAtoms__default: *mut nsIAtom; + pub static nsGkAtoms__default: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18headerDefaultStyleE"] - pub static nsGkAtoms_headerDefaultStyle: *mut nsIAtom; + pub static nsGkAtoms_headerDefaultStyle: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13defaultActionE"] - pub static nsGkAtoms_defaultAction: *mut nsIAtom; + pub static nsGkAtoms_defaultAction: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14defaultcheckedE"] - pub static nsGkAtoms_defaultchecked: *mut nsIAtom; + pub static nsGkAtoms_defaultchecked: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12defaultLabelE"] - pub static nsGkAtoms_defaultLabel: *mut nsIAtom; + pub static nsGkAtoms_defaultLabel: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15defaultselectedE"] - pub static nsGkAtoms_defaultselected: *mut nsIAtom; + pub static nsGkAtoms_defaultselected: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12defaultvalueE"] - pub static nsGkAtoms_defaultvalue: *mut nsIAtom; + pub static nsGkAtoms_defaultvalue: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19defaultplaybackrateE"] - pub static nsGkAtoms_defaultplaybackrate: *mut nsIAtom; + pub static nsGkAtoms_defaultplaybackrate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5deferE"] - pub static nsGkAtoms_defer: *mut nsIAtom; + pub static nsGkAtoms_defer: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3delE"] - pub static nsGkAtoms_del: *mut nsIAtom; + pub static nsGkAtoms_del: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10descendantE"] - pub static nsGkAtoms_descendant: *mut nsIAtom; + pub static nsGkAtoms_descendant: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16descendantOrSelfE"] - pub static nsGkAtoms_descendantOrSelf: *mut nsIAtom; + pub static nsGkAtoms_descendantOrSelf: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10descendingE"] - pub static nsGkAtoms_descending: *mut nsIAtom; + pub static nsGkAtoms_descending: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11descriptionE"] - pub static nsGkAtoms_description: *mut nsIAtom; + pub static nsGkAtoms_description: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10destructorE"] - pub static nsGkAtoms_destructor: *mut nsIAtom; + pub static nsGkAtoms_destructor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7detailsE"] - pub static nsGkAtoms_details: *mut nsIAtom; + pub static nsGkAtoms_details: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17deviceAspectRatioE"] - pub static nsGkAtoms_deviceAspectRatio: *mut nsIAtom; + pub static nsGkAtoms_deviceAspectRatio: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12deviceHeightE"] - pub static nsGkAtoms_deviceHeight: *mut nsIAtom; + pub static nsGkAtoms_deviceHeight: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16devicePixelRatioE"] - pub static nsGkAtoms_devicePixelRatio: *mut nsIAtom; + pub static nsGkAtoms_devicePixelRatio: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11deviceWidthE"] - pub static nsGkAtoms_deviceWidth: *mut nsIAtom; + pub static nsGkAtoms_deviceWidth: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3dfnE"] - pub static nsGkAtoms_dfn: *mut nsIAtom; + pub static nsGkAtoms_dfn: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6dialogE"] - pub static nsGkAtoms_dialog: *mut nsIAtom; + pub static nsGkAtoms_dialog: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10differenceE"] - pub static nsGkAtoms_difference: *mut nsIAtom; + pub static nsGkAtoms_difference: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5digitE"] - pub static nsGkAtoms_digit: *mut nsIAtom; + pub static nsGkAtoms_digit: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3dirE"] - pub static nsGkAtoms_dir: *mut nsIAtom; + pub static nsGkAtoms_dir: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12dirAutoSetByE"] - pub static nsGkAtoms_dirAutoSetBy: *mut nsIAtom; + pub static nsGkAtoms_dirAutoSetBy: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14directionalityE"] - pub static nsGkAtoms_directionality: *mut nsIAtom; + pub static nsGkAtoms_directionality: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9directoryE"] - pub static nsGkAtoms_directory: *mut nsIAtom; + pub static nsGkAtoms_directory: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21disableOutputEscapingE"] - pub static nsGkAtoms_disableOutputEscaping: *mut nsIAtom; + pub static nsGkAtoms_disableOutputEscaping: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8disabledE"] - pub static nsGkAtoms_disabled: *mut nsIAtom; + pub static nsGkAtoms_disabled: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20disableglobalhistoryE"] - pub static nsGkAtoms_disableglobalhistory: *mut nsIAtom; + pub static nsGkAtoms_disableglobalhistory: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14disablehistoryE"] - pub static nsGkAtoms_disablehistory: *mut nsIAtom; + pub static nsGkAtoms_disablehistory: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17disablefullscreenE"] - pub static nsGkAtoms_disablefullscreen: *mut nsIAtom; + pub static nsGkAtoms_disablefullscreen: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17disclosure_closedE"] - pub static nsGkAtoms_disclosure_closed: *mut nsIAtom; + pub static nsGkAtoms_disclosure_closed: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15disclosure_openE"] - pub static nsGkAtoms_disclosure_open: *mut nsIAtom; + pub static nsGkAtoms_disclosure_open: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7displayE"] - pub static nsGkAtoms_display: *mut nsIAtom; + pub static nsGkAtoms_display: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11displayModeE"] - pub static nsGkAtoms_displayMode: *mut nsIAtom; + pub static nsGkAtoms_displayMode: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8distinctE"] - pub static nsGkAtoms_distinct: *mut nsIAtom; + pub static nsGkAtoms_distinct: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3divE"] - pub static nsGkAtoms_div: *mut nsIAtom; + pub static nsGkAtoms_div: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2dlE"] - pub static nsGkAtoms_dl: *mut nsIAtom; + pub static nsGkAtoms_dl: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11docAbstractE"] - pub static nsGkAtoms_docAbstract: *mut nsIAtom; + pub static nsGkAtoms_docAbstract: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18docAcknowledgmentsE"] - pub static nsGkAtoms_docAcknowledgments: *mut nsIAtom; + pub static nsGkAtoms_docAcknowledgments: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12docAfterwordE"] - pub static nsGkAtoms_docAfterword: *mut nsIAtom; + pub static nsGkAtoms_docAfterword: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11docAppendixE"] - pub static nsGkAtoms_docAppendix: *mut nsIAtom; + pub static nsGkAtoms_docAppendix: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11docBacklinkE"] - pub static nsGkAtoms_docBacklink: *mut nsIAtom; + pub static nsGkAtoms_docBacklink: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14docBiblioentryE"] - pub static nsGkAtoms_docBiblioentry: *mut nsIAtom; + pub static nsGkAtoms_docBiblioentry: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15docBibliographyE"] - pub static nsGkAtoms_docBibliography: *mut nsIAtom; + pub static nsGkAtoms_docBibliography: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12docBibliorefE"] - pub static nsGkAtoms_docBiblioref: *mut nsIAtom; + pub static nsGkAtoms_docBiblioref: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10docChapterE"] - pub static nsGkAtoms_docChapter: *mut nsIAtom; + pub static nsGkAtoms_docChapter: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11docColophonE"] - pub static nsGkAtoms_docColophon: *mut nsIAtom; + pub static nsGkAtoms_docColophon: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13docConclusionE"] - pub static nsGkAtoms_docConclusion: *mut nsIAtom; + pub static nsGkAtoms_docConclusion: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8docCoverE"] - pub static nsGkAtoms_docCover: *mut nsIAtom; + pub static nsGkAtoms_docCover: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9docCreditE"] - pub static nsGkAtoms_docCredit: *mut nsIAtom; + pub static nsGkAtoms_docCredit: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10docCreditsE"] - pub static nsGkAtoms_docCredits: *mut nsIAtom; + pub static nsGkAtoms_docCredits: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13docDedicationE"] - pub static nsGkAtoms_docDedication: *mut nsIAtom; + pub static nsGkAtoms_docDedication: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10docEndnoteE"] - pub static nsGkAtoms_docEndnote: *mut nsIAtom; + pub static nsGkAtoms_docEndnote: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11docEndnotesE"] - pub static nsGkAtoms_docEndnotes: *mut nsIAtom; + pub static nsGkAtoms_docEndnotes: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11docEpigraphE"] - pub static nsGkAtoms_docEpigraph: *mut nsIAtom; + pub static nsGkAtoms_docEpigraph: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11docEpilogueE"] - pub static nsGkAtoms_docEpilogue: *mut nsIAtom; + pub static nsGkAtoms_docEpilogue: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9docErrataE"] - pub static nsGkAtoms_docErrata: *mut nsIAtom; + pub static nsGkAtoms_docErrata: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10docExampleE"] - pub static nsGkAtoms_docExample: *mut nsIAtom; + pub static nsGkAtoms_docExample: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11docFootnoteE"] - pub static nsGkAtoms_docFootnote: *mut nsIAtom; + pub static nsGkAtoms_docFootnote: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11docForewordE"] - pub static nsGkAtoms_docForeword: *mut nsIAtom; + pub static nsGkAtoms_docForeword: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11docGlossaryE"] - pub static nsGkAtoms_docGlossary: *mut nsIAtom; + pub static nsGkAtoms_docGlossary: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11docGlossrefE"] - pub static nsGkAtoms_docGlossref: *mut nsIAtom; + pub static nsGkAtoms_docGlossref: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8docIndexE"] - pub static nsGkAtoms_docIndex: *mut nsIAtom; + pub static nsGkAtoms_docIndex: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15docIntroductionE"] - pub static nsGkAtoms_docIntroduction: *mut nsIAtom; + pub static nsGkAtoms_docIntroduction: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10docNoterefE"] - pub static nsGkAtoms_docNoteref: *mut nsIAtom; + pub static nsGkAtoms_docNoteref: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9docNoticeE"] - pub static nsGkAtoms_docNotice: *mut nsIAtom; + pub static nsGkAtoms_docNotice: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12docPagebreakE"] - pub static nsGkAtoms_docPagebreak: *mut nsIAtom; + pub static nsGkAtoms_docPagebreak: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11docPagelistE"] - pub static nsGkAtoms_docPagelist: *mut nsIAtom; + pub static nsGkAtoms_docPagelist: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7docPartE"] - pub static nsGkAtoms_docPart: *mut nsIAtom; + pub static nsGkAtoms_docPart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10docPrefaceE"] - pub static nsGkAtoms_docPreface: *mut nsIAtom; + pub static nsGkAtoms_docPreface: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11docPrologueE"] - pub static nsGkAtoms_docPrologue: *mut nsIAtom; + pub static nsGkAtoms_docPrologue: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12docPullquoteE"] - pub static nsGkAtoms_docPullquote: *mut nsIAtom; + pub static nsGkAtoms_docPullquote: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6docQnaE"] - pub static nsGkAtoms_docQna: *mut nsIAtom; + pub static nsGkAtoms_docQna: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11docSubtitleE"] - pub static nsGkAtoms_docSubtitle: *mut nsIAtom; + pub static nsGkAtoms_docSubtitle: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6docTipE"] - pub static nsGkAtoms_docTip: *mut nsIAtom; + pub static nsGkAtoms_docTip: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6docTocE"] - pub static nsGkAtoms_docToc: *mut nsIAtom; + pub static nsGkAtoms_docToc: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13doctypePublicE"] - pub static nsGkAtoms_doctypePublic: *mut nsIAtom; + pub static nsGkAtoms_doctypePublic: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13doctypeSystemE"] - pub static nsGkAtoms_doctypeSystem: *mut nsIAtom; + pub static nsGkAtoms_doctypeSystem: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8documentE"] - pub static nsGkAtoms_document: *mut nsIAtom; + pub static nsGkAtoms_document: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8downloadE"] - pub static nsGkAtoms_download: *mut nsIAtom; + pub static nsGkAtoms_download: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15DOMAttrModifiedE"] - pub static nsGkAtoms_DOMAttrModified: *mut nsIAtom; + pub static nsGkAtoms_DOMAttrModified: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24DOMCharacterDataModifiedE"] - pub static nsGkAtoms_DOMCharacterDataModified: *mut nsIAtom; + pub static nsGkAtoms_DOMCharacterDataModified: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15DOMNodeInsertedE"] - pub static nsGkAtoms_DOMNodeInserted: *mut nsIAtom; + pub static nsGkAtoms_DOMNodeInserted: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms27DOMNodeInsertedIntoDocumentE"] - pub static nsGkAtoms_DOMNodeInsertedIntoDocument: *mut nsIAtom; + pub static nsGkAtoms_DOMNodeInsertedIntoDocument: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14DOMNodeRemovedE"] - pub static nsGkAtoms_DOMNodeRemoved: *mut nsIAtom; + pub static nsGkAtoms_DOMNodeRemoved: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms26DOMNodeRemovedFromDocumentE"] - pub static nsGkAtoms_DOMNodeRemovedFromDocument: *mut nsIAtom; + pub static nsGkAtoms_DOMNodeRemovedFromDocument: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18DOMSubtreeModifiedE"] - pub static nsGkAtoms_DOMSubtreeModified: *mut nsIAtom; + pub static nsGkAtoms_DOMSubtreeModified: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7double_E"] - pub static nsGkAtoms_double_: *mut nsIAtom; + pub static nsGkAtoms_double_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4dragE"] - pub static nsGkAtoms_drag: *mut nsIAtom; + pub static nsGkAtoms_drag: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7dragendE"] - pub static nsGkAtoms_dragend: *mut nsIAtom; + pub static nsGkAtoms_dragend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9dragenterE"] - pub static nsGkAtoms_dragenter: *mut nsIAtom; + pub static nsGkAtoms_dragenter: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9drageventE"] - pub static nsGkAtoms_dragevent: *mut nsIAtom; + pub static nsGkAtoms_dragevent: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8dragexitE"] - pub static nsGkAtoms_dragexit: *mut nsIAtom; + pub static nsGkAtoms_dragexit: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9draggableE"] - pub static nsGkAtoms_draggable: *mut nsIAtom; + pub static nsGkAtoms_draggable: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8draggingE"] - pub static nsGkAtoms_dragging: *mut nsIAtom; + pub static nsGkAtoms_dragging: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9dragleaveE"] - pub static nsGkAtoms_dragleave: *mut nsIAtom; + pub static nsGkAtoms_dragleave: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8dragoverE"] - pub static nsGkAtoms_dragover: *mut nsIAtom; + pub static nsGkAtoms_dragover: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11dragSessionE"] - pub static nsGkAtoms_dragSession: *mut nsIAtom; + pub static nsGkAtoms_dragSession: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9dragstartE"] - pub static nsGkAtoms_dragstart: *mut nsIAtom; + pub static nsGkAtoms_dragstart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14drawintitlebarE"] - pub static nsGkAtoms_drawintitlebar: *mut nsIAtom; + pub static nsGkAtoms_drawintitlebar: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9drawtitleE"] - pub static nsGkAtoms_drawtitle: *mut nsIAtom; + pub static nsGkAtoms_drawtitle: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4dropE"] - pub static nsGkAtoms_drop: *mut nsIAtom; + pub static nsGkAtoms_drop: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9dropAfterE"] - pub static nsGkAtoms_dropAfter: *mut nsIAtom; + pub static nsGkAtoms_dropAfter: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10dropBeforeE"] - pub static nsGkAtoms_dropBefore: *mut nsIAtom; + pub static nsGkAtoms_dropBefore: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6dropOnE"] - pub static nsGkAtoms_dropOn: *mut nsIAtom; + pub static nsGkAtoms_dropOn: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10dropMarkerE"] - pub static nsGkAtoms_dropMarker: *mut nsIAtom; + pub static nsGkAtoms_dropMarker: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2dtE"] - pub static nsGkAtoms_dt: *mut nsIAtom; + pub static nsGkAtoms_dt: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8editableE"] - pub static nsGkAtoms_editable: *mut nsIAtom; + pub static nsGkAtoms_editable: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7editingE"] - pub static nsGkAtoms_editing: *mut nsIAtom; + pub static nsGkAtoms_editing: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6editorE"] - pub static nsGkAtoms_editor: *mut nsIAtom; + pub static nsGkAtoms_editor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17editorDisplayListE"] - pub static nsGkAtoms_editorDisplayList: *mut nsIAtom; + pub static nsGkAtoms_editorDisplayList: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7elementE"] - pub static nsGkAtoms_element: *mut nsIAtom; + pub static nsGkAtoms_element: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16elementAvailableE"] - pub static nsGkAtoms_elementAvailable: *mut nsIAtom; + pub static nsGkAtoms_elementAvailable: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8elementsE"] - pub static nsGkAtoms_elements: *mut nsIAtom; + pub static nsGkAtoms_elements: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2emE"] - pub static nsGkAtoms_em: *mut nsIAtom; + pub static nsGkAtoms_em: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5embedE"] - pub static nsGkAtoms_embed: *mut nsIAtom; + pub static nsGkAtoms_embed: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8embossedE"] - pub static nsGkAtoms_embossed: *mut nsIAtom; + pub static nsGkAtoms_embossed: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5emptyE"] - pub static nsGkAtoms_empty: *mut nsIAtom; + pub static nsGkAtoms_empty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8encodingE"] - pub static nsGkAtoms_encoding: *mut nsIAtom; + pub static nsGkAtoms_encoding: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7enctypeE"] - pub static nsGkAtoms_enctype: *mut nsIAtom; + pub static nsGkAtoms_enctype: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3endE"] - pub static nsGkAtoms_end: *mut nsIAtom; + pub static nsGkAtoms_end: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8endEventE"] - pub static nsGkAtoms_endEvent: *mut nsIAtom; + pub static nsGkAtoms_endEvent: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9end_afterE"] - pub static nsGkAtoms_end_after: *mut nsIAtom; + pub static nsGkAtoms_end_after: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10end_beforeE"] - pub static nsGkAtoms_end_before: *mut nsIAtom; + pub static nsGkAtoms_end_before: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9equalsizeE"] - pub static nsGkAtoms_equalsize: *mut nsIAtom; + pub static nsGkAtoms_equalsize: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5errorE"] - pub static nsGkAtoms_error: *mut nsIAtom; + pub static nsGkAtoms_error: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16ethiopic_numericE"] - pub static nsGkAtoms_ethiopic_numeric: *mut nsIAtom; + pub static nsGkAtoms_ethiopic_numeric: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4evenE"] - pub static nsGkAtoms_even: *mut nsIAtom; + pub static nsGkAtoms_even: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5eventE"] - pub static nsGkAtoms_event: *mut nsIAtom; + pub static nsGkAtoms_event: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6eventsE"] - pub static nsGkAtoms_events: *mut nsIAtom; + pub static nsGkAtoms_events: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21excludeResultPrefixesE"] - pub static nsGkAtoms_excludeResultPrefixes: *mut nsIAtom; + pub static nsGkAtoms_excludeResultPrefixes: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8excludesE"] - pub static nsGkAtoms_excludes: *mut nsIAtom; + pub static nsGkAtoms_excludes: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4exprE"] - pub static nsGkAtoms_expr: *mut nsIAtom; + pub static nsGkAtoms_expr: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7extendsE"] - pub static nsGkAtoms_extends: *mut nsIAtom; + pub static nsGkAtoms_extends: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24extensionElementPrefixesE"] - pub static nsGkAtoms_extensionElementPrefixes: *mut nsIAtom; + pub static nsGkAtoms_extensionElementPrefixes: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4faceE"] - pub static nsGkAtoms_face: *mut nsIAtom; + pub static nsGkAtoms_face: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8fallbackE"] - pub static nsGkAtoms_fallback: *mut nsIAtom; + pub static nsGkAtoms_fallback: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6_falseE"] - pub static nsGkAtoms__false: *mut nsIAtom; + pub static nsGkAtoms__false: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8farthestE"] - pub static nsGkAtoms_farthest: *mut nsIAtom; + pub static nsGkAtoms_farthest: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5fieldE"] - pub static nsGkAtoms_field: *mut nsIAtom; + pub static nsGkAtoms_field: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8fieldsetE"] - pub static nsGkAtoms_fieldset: *mut nsIAtom; + pub static nsGkAtoms_fieldset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4fileE"] - pub static nsGkAtoms_file: *mut nsIAtom; + pub static nsGkAtoms_file: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10figcaptionE"] - pub static nsGkAtoms_figcaption: *mut nsIAtom; + pub static nsGkAtoms_figcaption: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6figureE"] - pub static nsGkAtoms_figure: *mut nsIAtom; + pub static nsGkAtoms_figure: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5fixedE"] - pub static nsGkAtoms_fixed: *mut nsIAtom; + pub static nsGkAtoms_fixed: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5flagsE"] - pub static nsGkAtoms_flags: *mut nsIAtom; + pub static nsGkAtoms_flags: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4flexE"] - pub static nsGkAtoms_flex: *mut nsIAtom; + pub static nsGkAtoms_flex: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9flexgroupE"] - pub static nsGkAtoms_flexgroup: *mut nsIAtom; + pub static nsGkAtoms_flexgroup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4flipE"] - pub static nsGkAtoms_flip: *mut nsIAtom; + pub static nsGkAtoms_flip: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8floatingE"] - pub static nsGkAtoms_floating: *mut nsIAtom; + pub static nsGkAtoms_floating: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5floorE"] - pub static nsGkAtoms_floor: *mut nsIAtom; + pub static nsGkAtoms_floor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10flowlengthE"] - pub static nsGkAtoms_flowlength: *mut nsIAtom; + pub static nsGkAtoms_flowlength: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5focusE"] - pub static nsGkAtoms_focus: *mut nsIAtom; + pub static nsGkAtoms_focus: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7focusedE"] - pub static nsGkAtoms_focused: *mut nsIAtom; + pub static nsGkAtoms_focused: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12followanchorE"] - pub static nsGkAtoms_followanchor: *mut nsIAtom; + pub static nsGkAtoms_followanchor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9followingE"] - pub static nsGkAtoms_following: *mut nsIAtom; + pub static nsGkAtoms_following: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16followingSiblingE"] - pub static nsGkAtoms_followingSibling: *mut nsIAtom; + pub static nsGkAtoms_followingSibling: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4fontE"] - pub static nsGkAtoms_font: *mut nsIAtom; + pub static nsGkAtoms_font: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10fontWeightE"] - pub static nsGkAtoms_fontWeight: *mut nsIAtom; + pub static nsGkAtoms_fontWeight: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10fontpickerE"] - pub static nsGkAtoms_fontpicker: *mut nsIAtom; + pub static nsGkAtoms_fontpicker: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6footerE"] - pub static nsGkAtoms_footer: *mut nsIAtom; + pub static nsGkAtoms_footer: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4_forE"] - pub static nsGkAtoms__for: *mut nsIAtom; + pub static nsGkAtoms__for: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7forEachE"] - pub static nsGkAtoms_forEach: *mut nsIAtom; + pub static nsGkAtoms_forEach: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21forceOwnRefreshDriverE"] - pub static nsGkAtoms_forceOwnRefreshDriver: *mut nsIAtom; + pub static nsGkAtoms_forceOwnRefreshDriver: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4formE"] - pub static nsGkAtoms_form: *mut nsIAtom; + pub static nsGkAtoms_form: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10formactionE"] - pub static nsGkAtoms_formaction: *mut nsIAtom; + pub static nsGkAtoms_formaction: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6formatE"] - pub static nsGkAtoms_format: *mut nsIAtom; + pub static nsGkAtoms_format: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12formatNumberE"] - pub static nsGkAtoms_formatNumber: *mut nsIAtom; + pub static nsGkAtoms_formatNumber: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11formenctypeE"] - pub static nsGkAtoms_formenctype: *mut nsIAtom; + pub static nsGkAtoms_formenctype: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10formmethodE"] - pub static nsGkAtoms_formmethod: *mut nsIAtom; + pub static nsGkAtoms_formmethod: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14formnovalidateE"] - pub static nsGkAtoms_formnovalidate: *mut nsIAtom; + pub static nsGkAtoms_formnovalidate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10formtargetE"] - pub static nsGkAtoms_formtarget: *mut nsIAtom; + pub static nsGkAtoms_formtarget: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5frameE"] - pub static nsGkAtoms_frame: *mut nsIAtom; + pub static nsGkAtoms_frame: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11frameborderE"] - pub static nsGkAtoms_frameborder: *mut nsIAtom; + pub static nsGkAtoms_frameborder: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8framesetE"] - pub static nsGkAtoms_frameset: *mut nsIAtom; + pub static nsGkAtoms_frameset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4fromE"] - pub static nsGkAtoms_from: *mut nsIAtom; + pub static nsGkAtoms_from: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16fullscreenchangeE"] - pub static nsGkAtoms_fullscreenchange: *mut nsIAtom; + pub static nsGkAtoms_fullscreenchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15fullscreenerrorE"] - pub static nsGkAtoms_fullscreenerror: *mut nsIAtom; + pub static nsGkAtoms_fullscreenerror: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17functionAvailableE"] - pub static nsGkAtoms_functionAvailable: *mut nsIAtom; + pub static nsGkAtoms_functionAvailable: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12freshProcessE"] - pub static nsGkAtoms_freshProcess: *mut nsIAtom; + pub static nsGkAtoms_freshProcess: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10generateIdE"] - pub static nsGkAtoms_generateId: *mut nsIAtom; + pub static nsGkAtoms_generateId: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6getterE"] - pub static nsGkAtoms_getter: *mut nsIAtom; + pub static nsGkAtoms_getter: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9glyphcharE"] - pub static nsGkAtoms_glyphchar: *mut nsIAtom; + pub static nsGkAtoms_glyphchar: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7glyphidE"] - pub static nsGkAtoms_glyphid: *mut nsIAtom; + pub static nsGkAtoms_glyphid: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4gridE"] - pub static nsGkAtoms_grid: *mut nsIAtom; + pub static nsGkAtoms_grid: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6grippyE"] - pub static nsGkAtoms_grippy: *mut nsIAtom; + pub static nsGkAtoms_grippy: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5groupE"] - pub static nsGkAtoms_group: *mut nsIAtom; + pub static nsGkAtoms_group: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17groupingSeparatorE"] - pub static nsGkAtoms_groupingSeparator: *mut nsIAtom; + pub static nsGkAtoms_groupingSeparator: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12groupingSizeE"] - pub static nsGkAtoms_groupingSize: *mut nsIAtom; + pub static nsGkAtoms_groupingSize: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4growE"] - pub static nsGkAtoms_grow: *mut nsIAtom; + pub static nsGkAtoms_grow: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6gutterE"] - pub static nsGkAtoms_gutter: *mut nsIAtom; + pub static nsGkAtoms_gutter: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2h1E"] - pub static nsGkAtoms_h1: *mut nsIAtom; + pub static nsGkAtoms_h1: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2h2E"] - pub static nsGkAtoms_h2: *mut nsIAtom; + pub static nsGkAtoms_h2: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2h3E"] - pub static nsGkAtoms_h3: *mut nsIAtom; + pub static nsGkAtoms_h3: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2h4E"] - pub static nsGkAtoms_h4: *mut nsIAtom; + pub static nsGkAtoms_h4: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2h5E"] - pub static nsGkAtoms_h5: *mut nsIAtom; + pub static nsGkAtoms_h5: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2h6E"] - pub static nsGkAtoms_h6: *mut nsIAtom; + pub static nsGkAtoms_h6: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8handheldE"] - pub static nsGkAtoms_handheld: *mut nsIAtom; + pub static nsGkAtoms_handheld: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16handheldFriendlyE"] - pub static nsGkAtoms_handheldFriendly: *mut nsIAtom; + pub static nsGkAtoms_handheldFriendly: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7handlerE"] - pub static nsGkAtoms_handler: *mut nsIAtom; + pub static nsGkAtoms_handler: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8handlersE"] - pub static nsGkAtoms_handlers: *mut nsIAtom; + pub static nsGkAtoms_handlers: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4HARDE"] - pub static nsGkAtoms_HARD: *mut nsIAtom; + pub static nsGkAtoms_HARD: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8haspopupE"] - pub static nsGkAtoms_haspopup: *mut nsIAtom; + pub static nsGkAtoms_haspopup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11hasSameNodeE"] - pub static nsGkAtoms_hasSameNode: *mut nsIAtom; + pub static nsGkAtoms_hasSameNode: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4hboxE"] - pub static nsGkAtoms_hbox: *mut nsIAtom; + pub static nsGkAtoms_hbox: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4headE"] - pub static nsGkAtoms_head: *mut nsIAtom; + pub static nsGkAtoms_head: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6headerE"] - pub static nsGkAtoms_header: *mut nsIAtom; + pub static nsGkAtoms_header: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7headersE"] - pub static nsGkAtoms_headers: *mut nsIAtom; + pub static nsGkAtoms_headers: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6hebrewE"] - pub static nsGkAtoms_hebrew: *mut nsIAtom; + pub static nsGkAtoms_hebrew: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6heightE"] - pub static nsGkAtoms_height: *mut nsIAtom; + pub static nsGkAtoms_height: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6hgroupE"] - pub static nsGkAtoms_hgroup: *mut nsIAtom; + pub static nsGkAtoms_hgroup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6hiddenE"] - pub static nsGkAtoms_hidden: *mut nsIAtom; + pub static nsGkAtoms_hidden: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10hidechromeE"] - pub static nsGkAtoms_hidechrome: *mut nsIAtom; + pub static nsGkAtoms_hidechrome: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16hidecolumnpickerE"] - pub static nsGkAtoms_hidecolumnpicker: *mut nsIAtom; + pub static nsGkAtoms_hidecolumnpicker: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4highE"] - pub static nsGkAtoms_high: *mut nsIAtom; + pub static nsGkAtoms_high: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7highestE"] - pub static nsGkAtoms_highest: *mut nsIAtom; + pub static nsGkAtoms_highest: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10horizontalE"] - pub static nsGkAtoms_horizontal: *mut nsIAtom; + pub static nsGkAtoms_horizontal: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5hoverE"] - pub static nsGkAtoms_hover: *mut nsIAtom; + pub static nsGkAtoms_hover: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2hrE"] - pub static nsGkAtoms_hr: *mut nsIAtom; + pub static nsGkAtoms_hr: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4hrefE"] - pub static nsGkAtoms_href: *mut nsIAtom; + pub static nsGkAtoms_href: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8hreflangE"] - pub static nsGkAtoms_hreflang: *mut nsIAtom; + pub static nsGkAtoms_hreflang: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6hspaceE"] - pub static nsGkAtoms_hspace: *mut nsIAtom; + pub static nsGkAtoms_hspace: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4htmlE"] - pub static nsGkAtoms_html: *mut nsIAtom; + pub static nsGkAtoms_html: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9httpEquivE"] - pub static nsGkAtoms_httpEquiv: *mut nsIAtom; + pub static nsGkAtoms_httpEquiv: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms1iE"] - pub static nsGkAtoms_i: *mut nsIAtom; + pub static nsGkAtoms_i: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4iconE"] - pub static nsGkAtoms_icon: *mut nsIAtom; + pub static nsGkAtoms_icon: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2idE"] - pub static nsGkAtoms_id: *mut nsIAtom; + pub static nsGkAtoms_id: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3_ifE"] - pub static nsGkAtoms__if: *mut nsIAtom; + pub static nsGkAtoms__if: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6iframeE"] - pub static nsGkAtoms_iframe: *mut nsIAtom; + pub static nsGkAtoms_iframe: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10ignorecaseE"] - pub static nsGkAtoms_ignorecase: *mut nsIAtom; + pub static nsGkAtoms_ignorecase: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10ignorekeysE"] - pub static nsGkAtoms_ignorekeys: *mut nsIAtom; + pub static nsGkAtoms_ignorekeys: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15ignoreuserfocusE"] - pub static nsGkAtoms_ignoreuserfocus: *mut nsIAtom; + pub static nsGkAtoms_ignoreuserfocus: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6ilayerE"] - pub static nsGkAtoms_ilayer: *mut nsIAtom; + pub static nsGkAtoms_ilayer: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5imageE"] - pub static nsGkAtoms_image: *mut nsIAtom; + pub static nsGkAtoms_image: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17imageClickedPointE"] - pub static nsGkAtoms_imageClickedPoint: *mut nsIAtom; + pub static nsGkAtoms_imageClickedPoint: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3imgE"] - pub static nsGkAtoms_img: *mut nsIAtom; + pub static nsGkAtoms_img: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14implementationE"] - pub static nsGkAtoms_implementation: *mut nsIAtom; + pub static nsGkAtoms_implementation: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10implementsE"] - pub static nsGkAtoms_implements: *mut nsIAtom; + pub static nsGkAtoms_implements: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6importE"] - pub static nsGkAtoms_import: *mut nsIAtom; + pub static nsGkAtoms_import: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21inactivetitlebarcolorE"] - pub static nsGkAtoms_inactivetitlebarcolor: *mut nsIAtom; + pub static nsGkAtoms_inactivetitlebarcolor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7includeE"] - pub static nsGkAtoms_include: *mut nsIAtom; + pub static nsGkAtoms_include: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8includesE"] - pub static nsGkAtoms_includes: *mut nsIAtom; + pub static nsGkAtoms_includes: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9incrementE"] - pub static nsGkAtoms_increment: *mut nsIAtom; + pub static nsGkAtoms_increment: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6indentE"] - pub static nsGkAtoms_indent: *mut nsIAtom; + pub static nsGkAtoms_indent: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13indeterminateE"] - pub static nsGkAtoms_indeterminate: *mut nsIAtom; + pub static nsGkAtoms_indeterminate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5indexE"] - pub static nsGkAtoms_index: *mut nsIAtom; + pub static nsGkAtoms_index: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5inferE"] - pub static nsGkAtoms_infer: *mut nsIAtom; + pub static nsGkAtoms_infer: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8infinityE"] - pub static nsGkAtoms_infinity: *mut nsIAtom; + pub static nsGkAtoms_infinity: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7inheritE"] - pub static nsGkAtoms_inherit: *mut nsIAtom; + pub static nsGkAtoms_inherit: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8inheritsE"] - pub static nsGkAtoms_inherits: *mut nsIAtom; + pub static nsGkAtoms_inherits: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12inheritstyleE"] - pub static nsGkAtoms_inheritstyle: *mut nsIAtom; + pub static nsGkAtoms_inheritstyle: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13initial_scaleE"] - pub static nsGkAtoms_initial_scale: *mut nsIAtom; + pub static nsGkAtoms_initial_scale: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5inputE"] - pub static nsGkAtoms_input: *mut nsIAtom; + pub static nsGkAtoms_input: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9inputmodeE"] - pub static nsGkAtoms_inputmode: *mut nsIAtom; + pub static nsGkAtoms_inputmode: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3insE"] - pub static nsGkAtoms_ins: *mut nsIAtom; + pub static nsGkAtoms_ins: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11insertafterE"] - pub static nsGkAtoms_insertafter: *mut nsIAtom; + pub static nsGkAtoms_insertafter: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12insertbeforeE"] - pub static nsGkAtoms_insertbefore: *mut nsIAtom; + pub static nsGkAtoms_insertbefore: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7installE"] - pub static nsGkAtoms_install: *mut nsIAtom; + pub static nsGkAtoms_install: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10instanceOfE"] - pub static nsGkAtoms_instanceOf: *mut nsIAtom; + pub static nsGkAtoms_instanceOf: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5int32E"] - pub static nsGkAtoms_int32: *mut nsIAtom; + pub static nsGkAtoms_int32: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5int64E"] - pub static nsGkAtoms_int64: *mut nsIAtom; + pub static nsGkAtoms_int64: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7integerE"] - pub static nsGkAtoms_integer: *mut nsIAtom; + pub static nsGkAtoms_integer: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9integrityE"] - pub static nsGkAtoms_integrity: *mut nsIAtom; + pub static nsGkAtoms_integrity: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12intersectionE"] - pub static nsGkAtoms_intersection: *mut nsIAtom; + pub static nsGkAtoms_intersection: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2isE"] - pub static nsGkAtoms_is: *mut nsIAtom; + pub static nsGkAtoms_is: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11iscontainerE"] - pub static nsGkAtoms_iscontainer: *mut nsIAtom; + pub static nsGkAtoms_iscontainer: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7isemptyE"] - pub static nsGkAtoms_isempty: *mut nsIAtom; + pub static nsGkAtoms_isempty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5ismapE"] - pub static nsGkAtoms_ismap: *mut nsIAtom; + pub static nsGkAtoms_ismap: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6itemidE"] - pub static nsGkAtoms_itemid: *mut nsIAtom; + pub static nsGkAtoms_itemid: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8itempropE"] - pub static nsGkAtoms_itemprop: *mut nsIAtom; + pub static nsGkAtoms_itemprop: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7itemrefE"] - pub static nsGkAtoms_itemref: *mut nsIAtom; + pub static nsGkAtoms_itemref: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9itemscopeE"] - pub static nsGkAtoms_itemscope: *mut nsIAtom; + pub static nsGkAtoms_itemscope: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8itemtypeE"] - pub static nsGkAtoms_itemtype: *mut nsIAtom; + pub static nsGkAtoms_itemtype: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15japanese_formalE"] - pub static nsGkAtoms_japanese_formal: *mut nsIAtom; + pub static nsGkAtoms_japanese_formal: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17japanese_informalE"] - pub static nsGkAtoms_japanese_informal: *mut nsIAtom; + pub static nsGkAtoms_japanese_informal: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3kbdE"] - pub static nsGkAtoms_kbd: *mut nsIAtom; + pub static nsGkAtoms_kbd: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17keepcurrentinviewE"] - pub static nsGkAtoms_keepcurrentinview: *mut nsIAtom; + pub static nsGkAtoms_keepcurrentinview: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16keepobjectsaliveE"] - pub static nsGkAtoms_keepobjectsalive: *mut nsIAtom; + pub static nsGkAtoms_keepobjectsalive: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3keyE"] - pub static nsGkAtoms_key: *mut nsIAtom; + pub static nsGkAtoms_key: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7keycodeE"] - pub static nsGkAtoms_keycode: *mut nsIAtom; + pub static nsGkAtoms_keycode: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17keystatuseschangeE"] - pub static nsGkAtoms_keystatuseschange: *mut nsIAtom; + pub static nsGkAtoms_keystatuseschange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7keydownE"] - pub static nsGkAtoms_keydown: *mut nsIAtom; + pub static nsGkAtoms_keydown: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6keygenE"] - pub static nsGkAtoms_keygen: *mut nsIAtom; + pub static nsGkAtoms_keygen: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8keypressE"] - pub static nsGkAtoms_keypress: *mut nsIAtom; + pub static nsGkAtoms_keypress: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6keysetE"] - pub static nsGkAtoms_keyset: *mut nsIAtom; + pub static nsGkAtoms_keyset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9keysystemE"] - pub static nsGkAtoms_keysystem: *mut nsIAtom; + pub static nsGkAtoms_keysystem: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7keytextE"] - pub static nsGkAtoms_keytext: *mut nsIAtom; + pub static nsGkAtoms_keytext: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5keyupE"] - pub static nsGkAtoms_keyup: *mut nsIAtom; + pub static nsGkAtoms_keyup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4kindE"] - pub static nsGkAtoms_kind: *mut nsIAtom; + pub static nsGkAtoms_kind: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20korean_hangul_formalE"] - pub static nsGkAtoms_korean_hangul_formal: *mut nsIAtom; + pub static nsGkAtoms_korean_hangul_formal: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19korean_hanja_formalE"] - pub static nsGkAtoms_korean_hanja_formal: *mut nsIAtom; + pub static nsGkAtoms_korean_hanja_formal: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21korean_hanja_informalE"] - pub static nsGkAtoms_korean_hanja_informal: *mut nsIAtom; + pub static nsGkAtoms_korean_hanja_informal: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5labelE"] - pub static nsGkAtoms_label: *mut nsIAtom; + pub static nsGkAtoms_label: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6labelsE"] - pub static nsGkAtoms_labels: *mut nsIAtom; + pub static nsGkAtoms_labels: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4langE"] - pub static nsGkAtoms_lang: *mut nsIAtom; + pub static nsGkAtoms_lang: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8languageE"] - pub static nsGkAtoms_language: *mut nsIAtom; + pub static nsGkAtoms_language: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4lastE"] - pub static nsGkAtoms_last: *mut nsIAtom; + pub static nsGkAtoms_last: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5layerE"] - pub static nsGkAtoms_layer: *mut nsIAtom; + pub static nsGkAtoms_layer: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13LayerActivityE"] - pub static nsGkAtoms_LayerActivity: *mut nsIAtom; + pub static nsGkAtoms_LayerActivity: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6layoutE"] - pub static nsGkAtoms_layout: *mut nsIAtom; + pub static nsGkAtoms_layout: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7leadingE"] - pub static nsGkAtoms_leading: *mut nsIAtom; + pub static nsGkAtoms_leading: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4leafE"] - pub static nsGkAtoms_leaf: *mut nsIAtom; + pub static nsGkAtoms_leaf: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4leftE"] - pub static nsGkAtoms_left: *mut nsIAtom; + pub static nsGkAtoms_left: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10leftmarginE"] - pub static nsGkAtoms_leftmargin: *mut nsIAtom; + pub static nsGkAtoms_leftmargin: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11leftpaddingE"] - pub static nsGkAtoms_leftpadding: *mut nsIAtom; + pub static nsGkAtoms_leftpadding: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6legendE"] - pub static nsGkAtoms_legend: *mut nsIAtom; + pub static nsGkAtoms_legend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6lengthE"] - pub static nsGkAtoms_length: *mut nsIAtom; + pub static nsGkAtoms_length: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11letterValueE"] - pub static nsGkAtoms_letterValue: *mut nsIAtom; + pub static nsGkAtoms_letterValue: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5levelE"] - pub static nsGkAtoms_level: *mut nsIAtom; + pub static nsGkAtoms_level: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2liE"] - pub static nsGkAtoms_li: *mut nsIAtom; + pub static nsGkAtoms_li: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4lineE"] - pub static nsGkAtoms_line: *mut nsIAtom; + pub static nsGkAtoms_line: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4linkE"] - pub static nsGkAtoms_link: *mut nsIAtom; + pub static nsGkAtoms_link: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4listE"] - pub static nsGkAtoms_list: *mut nsIAtom; + pub static nsGkAtoms_list: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7listboxE"] - pub static nsGkAtoms_listbox: *mut nsIAtom; + pub static nsGkAtoms_listbox: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11listboxbodyE"] - pub static nsGkAtoms_listboxbody: *mut nsIAtom; + pub static nsGkAtoms_listboxbody: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8listcellE"] - pub static nsGkAtoms_listcell: *mut nsIAtom; + pub static nsGkAtoms_listcell: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7listcolE"] - pub static nsGkAtoms_listcol: *mut nsIAtom; + pub static nsGkAtoms_listcol: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8listcolsE"] - pub static nsGkAtoms_listcols: *mut nsIAtom; + pub static nsGkAtoms_listcols: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8listenerE"] - pub static nsGkAtoms_listener: *mut nsIAtom; + pub static nsGkAtoms_listener: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8listheadE"] - pub static nsGkAtoms_listhead: *mut nsIAtom; + pub static nsGkAtoms_listhead: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10listheaderE"] - pub static nsGkAtoms_listheader: *mut nsIAtom; + pub static nsGkAtoms_listheader: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7listingE"] - pub static nsGkAtoms_listing: *mut nsIAtom; + pub static nsGkAtoms_listing: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8listitemE"] - pub static nsGkAtoms_listitem: *mut nsIAtom; + pub static nsGkAtoms_listitem: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8listrowsE"] - pub static nsGkAtoms_listrows: *mut nsIAtom; + pub static nsGkAtoms_listrows: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4loadE"] - pub static nsGkAtoms_load: *mut nsIAtom; + pub static nsGkAtoms_load: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16loadingprincipalE"] - pub static nsGkAtoms_loadingprincipal: *mut nsIAtom; + pub static nsGkAtoms_loadingprincipal: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9localedirE"] - pub static nsGkAtoms_localedir: *mut nsIAtom; + pub static nsGkAtoms_localedir: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9localNameE"] - pub static nsGkAtoms_localName: *mut nsIAtom; + pub static nsGkAtoms_localName: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8longdescE"] - pub static nsGkAtoms_longdesc: *mut nsIAtom; + pub static nsGkAtoms_longdesc: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4loopE"] - pub static nsGkAtoms_loop: *mut nsIAtom; + pub static nsGkAtoms_loop: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3lowE"] - pub static nsGkAtoms_low: *mut nsIAtom; + pub static nsGkAtoms_low: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10lowerAlphaE"] - pub static nsGkAtoms_lowerAlpha: *mut nsIAtom; + pub static nsGkAtoms_lowerAlpha: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10lowerFirstE"] - pub static nsGkAtoms_lowerFirst: *mut nsIAtom; + pub static nsGkAtoms_lowerFirst: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10lowerRomanE"] - pub static nsGkAtoms_lowerRoman: *mut nsIAtom; + pub static nsGkAtoms_lowerRoman: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6lowestE"] - pub static nsGkAtoms_lowest: *mut nsIAtom; + pub static nsGkAtoms_lowest: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6lowsrcE"] - pub static nsGkAtoms_lowsrc: *mut nsIAtom; + pub static nsGkAtoms_lowsrc: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3ltrE"] - pub static nsGkAtoms_ltr: *mut nsIAtom; + pub static nsGkAtoms_ltr: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7lwthemeE"] - pub static nsGkAtoms_lwtheme: *mut nsIAtom; + pub static nsGkAtoms_lwtheme: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16lwthemetextcolorE"] - pub static nsGkAtoms_lwthemetextcolor: *mut nsIAtom; + pub static nsGkAtoms_lwthemetextcolor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4mainE"] - pub static nsGkAtoms_main: *mut nsIAtom; + pub static nsGkAtoms_main: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3mapE"] - pub static nsGkAtoms_map: *mut nsIAtom; + pub static nsGkAtoms_map: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8manifestE"] - pub static nsGkAtoms_manifest: *mut nsIAtom; + pub static nsGkAtoms_manifest: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12marginBottomE"] - pub static nsGkAtoms_marginBottom: *mut nsIAtom; + pub static nsGkAtoms_marginBottom: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10marginLeftE"] - pub static nsGkAtoms_marginLeft: *mut nsIAtom; + pub static nsGkAtoms_marginLeft: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11marginRightE"] - pub static nsGkAtoms_marginRight: *mut nsIAtom; + pub static nsGkAtoms_marginRight: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9marginTopE"] - pub static nsGkAtoms_marginTop: *mut nsIAtom; + pub static nsGkAtoms_marginTop: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12marginheightE"] - pub static nsGkAtoms_marginheight: *mut nsIAtom; + pub static nsGkAtoms_marginheight: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11marginwidthE"] - pub static nsGkAtoms_marginwidth: *mut nsIAtom; + pub static nsGkAtoms_marginwidth: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4markE"] - pub static nsGkAtoms_mark: *mut nsIAtom; + pub static nsGkAtoms_mark: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7marqueeE"] - pub static nsGkAtoms_marquee: *mut nsIAtom; + pub static nsGkAtoms_marquee: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5matchE"] - pub static nsGkAtoms_match: *mut nsIAtom; + pub static nsGkAtoms_match: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3maxE"] - pub static nsGkAtoms_max: *mut nsIAtom; + pub static nsGkAtoms_max: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9maxheightE"] - pub static nsGkAtoms_maxheight: *mut nsIAtom; + pub static nsGkAtoms_maxheight: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13maximum_scaleE"] - pub static nsGkAtoms_maximum_scale: *mut nsIAtom; + pub static nsGkAtoms_maximum_scale: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9maxlengthE"] - pub static nsGkAtoms_maxlength: *mut nsIAtom; + pub static nsGkAtoms_maxlength: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6maxposE"] - pub static nsGkAtoms_maxpos: *mut nsIAtom; + pub static nsGkAtoms_maxpos: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8maxwidthE"] - pub static nsGkAtoms_maxwidth: *mut nsIAtom; + pub static nsGkAtoms_maxwidth: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9mayscriptE"] - pub static nsGkAtoms_mayscript: *mut nsIAtom; + pub static nsGkAtoms_mayscript: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5mediaE"] - pub static nsGkAtoms_media: *mut nsIAtom; + pub static nsGkAtoms_media: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9mediaTypeE"] - pub static nsGkAtoms_mediaType: *mut nsIAtom; + pub static nsGkAtoms_mediaType: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6memberE"] - pub static nsGkAtoms_member: *mut nsIAtom; + pub static nsGkAtoms_member: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4menuE"] - pub static nsGkAtoms_menu: *mut nsIAtom; + pub static nsGkAtoms_menu: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7menubarE"] - pub static nsGkAtoms_menubar: *mut nsIAtom; + pub static nsGkAtoms_menubar: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10menubuttonE"] - pub static nsGkAtoms_menubutton: *mut nsIAtom; + pub static nsGkAtoms_menubutton: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10menuButtonE"] - pub static nsGkAtoms_menuButton: *mut nsIAtom; + pub static nsGkAtoms_menuButton: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9menugroupE"] - pub static nsGkAtoms_menugroup: *mut nsIAtom; + pub static nsGkAtoms_menugroup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8menuitemE"] - pub static nsGkAtoms_menuitem: *mut nsIAtom; + pub static nsGkAtoms_menuitem: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8menulistE"] - pub static nsGkAtoms_menulist: *mut nsIAtom; + pub static nsGkAtoms_menulist: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9menupopupE"] - pub static nsGkAtoms_menupopup: *mut nsIAtom; + pub static nsGkAtoms_menupopup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13menuseparatorE"] - pub static nsGkAtoms_menuseparator: *mut nsIAtom; + pub static nsGkAtoms_menuseparator: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7messageE"] - pub static nsGkAtoms_message: *mut nsIAtom; + pub static nsGkAtoms_message: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4metaE"] - pub static nsGkAtoms_meta: *mut nsIAtom; + pub static nsGkAtoms_meta: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8referrerE"] - pub static nsGkAtoms_referrer: *mut nsIAtom; + pub static nsGkAtoms_referrer: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14referrerpolicyE"] - pub static nsGkAtoms_referrerpolicy: *mut nsIAtom; + pub static nsGkAtoms_referrerpolicy: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20headerReferrerPolicyE"] - pub static nsGkAtoms_headerReferrerPolicy: *mut nsIAtom; + pub static nsGkAtoms_headerReferrerPolicy: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5meterE"] - pub static nsGkAtoms_meter: *mut nsIAtom; + pub static nsGkAtoms_meter: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6methodE"] - pub static nsGkAtoms_method: *mut nsIAtom; + pub static nsGkAtoms_method: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6middleE"] - pub static nsGkAtoms_middle: *mut nsIAtom; + pub static nsGkAtoms_middle: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3minE"] - pub static nsGkAtoms_min: *mut nsIAtom; + pub static nsGkAtoms_min: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9minheightE"] - pub static nsGkAtoms_minheight: *mut nsIAtom; + pub static nsGkAtoms_minheight: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13minimum_scaleE"] - pub static nsGkAtoms_minimum_scale: *mut nsIAtom; + pub static nsGkAtoms_minimum_scale: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9minlengthE"] - pub static nsGkAtoms_minlength: *mut nsIAtom; + pub static nsGkAtoms_minlength: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6minposE"] - pub static nsGkAtoms_minpos: *mut nsIAtom; + pub static nsGkAtoms_minpos: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9minusSignE"] - pub static nsGkAtoms_minusSign: *mut nsIAtom; + pub static nsGkAtoms_minusSign: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8minwidthE"] - pub static nsGkAtoms_minwidth: *mut nsIAtom; + pub static nsGkAtoms_minwidth: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6_mixedE"] - pub static nsGkAtoms__mixed: *mut nsIAtom; + pub static nsGkAtoms__mixed: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19messagemanagergroupE"] - pub static nsGkAtoms_messagemanagergroup: *mut nsIAtom; + pub static nsGkAtoms_messagemanagergroup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3modE"] - pub static nsGkAtoms_mod: *mut nsIAtom; + pub static nsGkAtoms_mod: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4modeE"] - pub static nsGkAtoms_mode: *mut nsIAtom; + pub static nsGkAtoms_mode: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9modifiersE"] - pub static nsGkAtoms_modifiers: *mut nsIAtom; + pub static nsGkAtoms_modifiers: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10monochromeE"] - pub static nsGkAtoms_monochrome: *mut nsIAtom; + pub static nsGkAtoms_monochrome: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9mousedownE"] - pub static nsGkAtoms_mousedown: *mut nsIAtom; + pub static nsGkAtoms_mousedown: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9mousemoveE"] - pub static nsGkAtoms_mousemove: *mut nsIAtom; + pub static nsGkAtoms_mousemove: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8mouseoutE"] - pub static nsGkAtoms_mouseout: *mut nsIAtom; + pub static nsGkAtoms_mouseout: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9mouseoverE"] - pub static nsGkAtoms_mouseover: *mut nsIAtom; + pub static nsGkAtoms_mouseover: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12mousethroughE"] - pub static nsGkAtoms_mousethrough: *mut nsIAtom; + pub static nsGkAtoms_mousethrough: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7mouseupE"] - pub static nsGkAtoms_mouseup: *mut nsIAtom; + pub static nsGkAtoms_mouseup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19mozfullscreenchangeE"] - pub static nsGkAtoms_mozfullscreenchange: *mut nsIAtom; + pub static nsGkAtoms_mozfullscreenchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18mozfullscreenerrorE"] - pub static nsGkAtoms_mozfullscreenerror: *mut nsIAtom; + pub static nsGkAtoms_mozfullscreenerror: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20mozpointerlockchangeE"] - pub static nsGkAtoms_mozpointerlockchange: *mut nsIAtom; + pub static nsGkAtoms_mozpointerlockchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19mozpointerlockerrorE"] - pub static nsGkAtoms_mozpointerlockerror: *mut nsIAtom; + pub static nsGkAtoms_mozpointerlockerror: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18mozprivatebrowsingE"] - pub static nsGkAtoms_mozprivatebrowsing: *mut nsIAtom; + pub static nsGkAtoms_mozprivatebrowsing: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10moz_opaqueE"] - pub static nsGkAtoms_moz_opaque: *mut nsIAtom; + pub static nsGkAtoms_moz_opaque: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15moz_action_hintE"] - pub static nsGkAtoms_moz_action_hint: *mut nsIAtom; + pub static nsGkAtoms_moz_action_hint: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18x_moz_errormessageE"] - pub static nsGkAtoms_x_moz_errormessage: *mut nsIAtom; + pub static nsGkAtoms_x_moz_errormessage: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8multicolE"] - pub static nsGkAtoms_multicol: *mut nsIAtom; + pub static nsGkAtoms_multicol: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8multipleE"] - pub static nsGkAtoms_multiple: *mut nsIAtom; + pub static nsGkAtoms_multiple: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5mutedE"] - pub static nsGkAtoms_muted: *mut nsIAtom; + pub static nsGkAtoms_muted: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4nameE"] - pub static nsGkAtoms_name: *mut nsIAtom; + pub static nsGkAtoms_name: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10_namespaceE"] - pub static nsGkAtoms__namespace: *mut nsIAtom; + pub static nsGkAtoms__namespace: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14namespaceAliasE"] - pub static nsGkAtoms_namespaceAlias: *mut nsIAtom; + pub static nsGkAtoms_namespaceAlias: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12namespaceUriE"] - pub static nsGkAtoms_namespaceUri: *mut nsIAtom; + pub static nsGkAtoms_namespaceUri: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3NaNE"] - pub static nsGkAtoms_NaN: *mut nsIAtom; + pub static nsGkAtoms_NaN: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24nativeAnonymousChildListE"] - pub static nsGkAtoms_nativeAnonymousChildList: *mut nsIAtom; + pub static nsGkAtoms_nativeAnonymousChildList: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3navE"] - pub static nsGkAtoms_nav: *mut nsIAtom; + pub static nsGkAtoms_nav: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6negateE"] - pub static nsGkAtoms_negate: *mut nsIAtom; + pub static nsGkAtoms_negate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5neverE"] - pub static nsGkAtoms_never: *mut nsIAtom; + pub static nsGkAtoms_never: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4_newE"] - pub static nsGkAtoms__new: *mut nsIAtom; + pub static nsGkAtoms__new: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7newlineE"] - pub static nsGkAtoms_newline: *mut nsIAtom; + pub static nsGkAtoms_newline: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8nextBidiE"] - pub static nsGkAtoms_nextBidi: *mut nsIAtom; + pub static nsGkAtoms_nextBidi: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15nextTabParentIdE"] - pub static nsGkAtoms_nextTabParentId: *mut nsIAtom; + pub static nsGkAtoms_nextTabParentId: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2noE"] - pub static nsGkAtoms_no: *mut nsIAtom; + pub static nsGkAtoms_no: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11noautofocusE"] - pub static nsGkAtoms_noautofocus: *mut nsIAtom; + pub static nsGkAtoms_noautofocus: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10noautohideE"] - pub static nsGkAtoms_noautohide: *mut nsIAtom; + pub static nsGkAtoms_noautohide: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16norolluponanchorE"] - pub static nsGkAtoms_norolluponanchor: *mut nsIAtom; + pub static nsGkAtoms_norolluponanchor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4nobrE"] - pub static nsGkAtoms_nobr: *mut nsIAtom; + pub static nsGkAtoms_nobr: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4nodeE"] - pub static nsGkAtoms_node: *mut nsIAtom; + pub static nsGkAtoms_node: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12nodefaultsrcE"] - pub static nsGkAtoms_nodefaultsrc: *mut nsIAtom; + pub static nsGkAtoms_nodefaultsrc: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7nodeSetE"] - pub static nsGkAtoms_nodeSet: *mut nsIAtom; + pub static nsGkAtoms_nodeSet: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7noembedE"] - pub static nsGkAtoms_noembed: *mut nsIAtom; + pub static nsGkAtoms_noembed: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8noframesE"] - pub static nsGkAtoms_noframes: *mut nsIAtom; + pub static nsGkAtoms_noframes: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6nohrefE"] - pub static nsGkAtoms_nohref: *mut nsIAtom; + pub static nsGkAtoms_nohref: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11noisolationE"] - pub static nsGkAtoms_noisolation: *mut nsIAtom; + pub static nsGkAtoms_noisolation: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8nomoduleE"] - pub static nsGkAtoms_nomodule: *mut nsIAtom; + pub static nsGkAtoms_nomodule: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5nonceE"] - pub static nsGkAtoms_nonce: *mut nsIAtom; + pub static nsGkAtoms_nonce: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4noneE"] - pub static nsGkAtoms_none: *mut nsIAtom; + pub static nsGkAtoms_none: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8noresizeE"] - pub static nsGkAtoms_noresize: *mut nsIAtom; + pub static nsGkAtoms_noresize: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6normalE"] - pub static nsGkAtoms_normal: *mut nsIAtom; + pub static nsGkAtoms_normal: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14normalizeSpaceE"] - pub static nsGkAtoms_normalizeSpace: *mut nsIAtom; + pub static nsGkAtoms_normalizeSpace: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8noscriptE"] - pub static nsGkAtoms_noscript: *mut nsIAtom; + pub static nsGkAtoms_noscript: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7noshadeE"] - pub static nsGkAtoms_noshade: *mut nsIAtom; + pub static nsGkAtoms_noshade: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10novalidateE"] - pub static nsGkAtoms_novalidate: *mut nsIAtom; + pub static nsGkAtoms_novalidate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4_notE"] - pub static nsGkAtoms__not: *mut nsIAtom; + pub static nsGkAtoms__not: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6nowrapE"] - pub static nsGkAtoms_nowrap: *mut nsIAtom; + pub static nsGkAtoms_nowrap: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6numberE"] - pub static nsGkAtoms_number: *mut nsIAtom; + pub static nsGkAtoms_number: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4nullE"] - pub static nsGkAtoms_null: *mut nsIAtom; + pub static nsGkAtoms_null: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6objectE"] - pub static nsGkAtoms_object: *mut nsIAtom; + pub static nsGkAtoms_object: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10objectTypeE"] - pub static nsGkAtoms_objectType: *mut nsIAtom; + pub static nsGkAtoms_objectType: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8observerE"] - pub static nsGkAtoms_observer: *mut nsIAtom; + pub static nsGkAtoms_observer: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8observesE"] - pub static nsGkAtoms_observes: *mut nsIAtom; + pub static nsGkAtoms_observes: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3oddE"] - pub static nsGkAtoms_odd: *mut nsIAtom; + pub static nsGkAtoms_odd: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3OFFE"] - pub static nsGkAtoms_OFF: *mut nsIAtom; + pub static nsGkAtoms_OFF: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2olE"] - pub static nsGkAtoms_ol: *mut nsIAtom; + pub static nsGkAtoms_ol: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18omitXmlDeclarationE"] - pub static nsGkAtoms_omitXmlDeclaration: *mut nsIAtom; + pub static nsGkAtoms_omitXmlDeclaration: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19ona2dpstatuschangedE"] - pub static nsGkAtoms_ona2dpstatuschanged: *mut nsIAtom; + pub static nsGkAtoms_ona2dpstatuschanged: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7onabortE"] - pub static nsGkAtoms_onabort: *mut nsIAtom; + pub static nsGkAtoms_onabort: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms22onmozaccesskeynotfoundE"] - pub static nsGkAtoms_onmozaccesskeynotfound: *mut nsIAtom; + pub static nsGkAtoms_onmozaccesskeynotfound: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onactivateE"] - pub static nsGkAtoms_onactivate: *mut nsIAtom; + pub static nsGkAtoms_onactivate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14onadapteraddedE"] - pub static nsGkAtoms_onadapteradded: *mut nsIAtom; + pub static nsGkAtoms_onadapteradded: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16onadapterremovedE"] - pub static nsGkAtoms_onadapterremoved: *mut nsIAtom; + pub static nsGkAtoms_onadapterremoved: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onafterprintE"] - pub static nsGkAtoms_onafterprint: *mut nsIAtom; + pub static nsGkAtoms_onafterprint: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20onafterscriptexecuteE"] - pub static nsGkAtoms_onafterscriptexecute: *mut nsIAtom; + pub static nsGkAtoms_onafterscriptexecute: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onalertingE"] - pub static nsGkAtoms_onalerting: *mut nsIAtom; + pub static nsGkAtoms_onalerting: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17onanimationcancelE"] - pub static nsGkAtoms_onanimationcancel: *mut nsIAtom; + pub static nsGkAtoms_onanimationcancel: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14onanimationendE"] - pub static nsGkAtoms_onanimationend: *mut nsIAtom; + pub static nsGkAtoms_onanimationend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20onanimationiterationE"] - pub static nsGkAtoms_onanimationiteration: *mut nsIAtom; + pub static nsGkAtoms_onanimationiteration: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16onanimationstartE"] - pub static nsGkAtoms_onanimationstart: *mut nsIAtom; + pub static nsGkAtoms_onanimationstart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24onantennaavailablechangeE"] - pub static nsGkAtoms_onantennaavailablechange: *mut nsIAtom; + pub static nsGkAtoms_onantennaavailablechange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onAppCommandE"] - pub static nsGkAtoms_onAppCommand: *mut nsIAtom; + pub static nsGkAtoms_onAppCommand: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14onappinstalledE"] - pub static nsGkAtoms_onappinstalled: *mut nsIAtom; + pub static nsGkAtoms_onappinstalled: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18onattributechangedE"] - pub static nsGkAtoms_onattributechanged: *mut nsIAtom; + pub static nsGkAtoms_onattributechanged: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18onattributereadreqE"] - pub static nsGkAtoms_onattributereadreq: *mut nsIAtom; + pub static nsGkAtoms_onattributereadreq: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19onattributewritereqE"] - pub static nsGkAtoms_onattributewritereq: *mut nsIAtom; + pub static nsGkAtoms_onattributewritereq: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14onaudioprocessE"] - pub static nsGkAtoms_onaudioprocess: *mut nsIAtom; + pub static nsGkAtoms_onaudioprocess: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onauxclickE"] - pub static nsGkAtoms_onauxclick: *mut nsIAtom; + pub static nsGkAtoms_onauxclick: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onbeforecopyE"] - pub static nsGkAtoms_onbeforecopy: *mut nsIAtom; + pub static nsGkAtoms_onbeforecopy: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11onbeforecutE"] - pub static nsGkAtoms_onbeforecut: *mut nsIAtom; + pub static nsGkAtoms_onbeforecut: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onbeforepasteE"] - pub static nsGkAtoms_onbeforepaste: *mut nsIAtom; + pub static nsGkAtoms_onbeforepaste: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15onbeforeevictedE"] - pub static nsGkAtoms_onbeforeevicted: *mut nsIAtom; + pub static nsGkAtoms_onbeforeevicted: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onbeforeprintE"] - pub static nsGkAtoms_onbeforeprint: *mut nsIAtom; + pub static nsGkAtoms_onbeforeprint: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21onbeforescriptexecuteE"] - pub static nsGkAtoms_onbeforescriptexecute: *mut nsIAtom; + pub static nsGkAtoms_onbeforescriptexecute: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14onbeforeunloadE"] - pub static nsGkAtoms_onbeforeunload: *mut nsIAtom; + pub static nsGkAtoms_onbeforeunload: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onblockedE"] - pub static nsGkAtoms_onblocked: *mut nsIAtom; + pub static nsGkAtoms_onblocked: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6onblurE"] - pub static nsGkAtoms_onblur: *mut nsIAtom; + pub static nsGkAtoms_onblur: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11onbroadcastE"] - pub static nsGkAtoms_onbroadcast: *mut nsIAtom; + pub static nsGkAtoms_onbroadcast: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6onbusyE"] - pub static nsGkAtoms_onbusy: *mut nsIAtom; + pub static nsGkAtoms_onbusy: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19onbufferedamountlowE"] - pub static nsGkAtoms_onbufferedamountlow: *mut nsIAtom; + pub static nsGkAtoms_onbufferedamountlow: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8oncachedE"] - pub static nsGkAtoms_oncached: *mut nsIAtom; + pub static nsGkAtoms_oncached: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14oncallschangedE"] - pub static nsGkAtoms_oncallschanged: *mut nsIAtom; + pub static nsGkAtoms_oncallschanged: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8oncancelE"] - pub static nsGkAtoms_oncancel: *mut nsIAtom; + pub static nsGkAtoms_oncancel: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17oncardstatechangeE"] - pub static nsGkAtoms_oncardstatechange: *mut nsIAtom; + pub static nsGkAtoms_oncardstatechange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15oncfstatechangeE"] - pub static nsGkAtoms_oncfstatechange: *mut nsIAtom; + pub static nsGkAtoms_oncfstatechange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8onchangeE"] - pub static nsGkAtoms_onchange: *mut nsIAtom; + pub static nsGkAtoms_onchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23oncharacteristicchangedE"] - pub static nsGkAtoms_oncharacteristicchanged: *mut nsIAtom; + pub static nsGkAtoms_oncharacteristicchanged: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16onchargingchangeE"] - pub static nsGkAtoms_onchargingchange: *mut nsIAtom; + pub static nsGkAtoms_onchargingchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20onchargingtimechangeE"] - pub static nsGkAtoms_onchargingtimechange: *mut nsIAtom; + pub static nsGkAtoms_onchargingtimechange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10oncheckingE"] - pub static nsGkAtoms_onchecking: *mut nsIAtom; + pub static nsGkAtoms_onchecking: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21onCheckboxStateChangeE"] - pub static nsGkAtoms_onCheckboxStateChange: *mut nsIAtom; + pub static nsGkAtoms_onCheckboxStateChange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7onclickE"] - pub static nsGkAtoms_onclick: *mut nsIAtom; + pub static nsGkAtoms_onclick: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16onclirmodechangeE"] - pub static nsGkAtoms_onclirmodechange: *mut nsIAtom; + pub static nsGkAtoms_onclirmodechange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7oncloseE"] - pub static nsGkAtoms_onclose: *mut nsIAtom; + pub static nsGkAtoms_onclose: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9oncommandE"] - pub static nsGkAtoms_oncommand: *mut nsIAtom; + pub static nsGkAtoms_oncommand: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15oncommandupdateE"] - pub static nsGkAtoms_oncommandupdate: *mut nsIAtom; + pub static nsGkAtoms_oncommandupdate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10oncompleteE"] - pub static nsGkAtoms_oncomplete: *mut nsIAtom; + pub static nsGkAtoms_oncomplete: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16oncompositionendE"] - pub static nsGkAtoms_oncompositionend: *mut nsIAtom; + pub static nsGkAtoms_oncompositionend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18oncompositionstartE"] - pub static nsGkAtoms_oncompositionstart: *mut nsIAtom; + pub static nsGkAtoms_oncompositionstart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19oncompositionupdateE"] - pub static nsGkAtoms_oncompositionupdate: *mut nsIAtom; + pub static nsGkAtoms_oncompositionupdate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onconnectE"] - pub static nsGkAtoms_onconnect: *mut nsIAtom; + pub static nsGkAtoms_onconnect: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11onconnectedE"] - pub static nsGkAtoms_onconnected: *mut nsIAtom; + pub static nsGkAtoms_onconnected: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onconnectingE"] - pub static nsGkAtoms_onconnecting: *mut nsIAtom; + pub static nsGkAtoms_onconnecting: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21onconnectionavailableE"] - pub static nsGkAtoms_onconnectionavailable: *mut nsIAtom; + pub static nsGkAtoms_onconnectionavailable: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24onconnectionstatechangedE"] - pub static nsGkAtoms_onconnectionstatechanged: *mut nsIAtom; + pub static nsGkAtoms_onconnectionstatechanged: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13oncontextmenuE"] - pub static nsGkAtoms_oncontextmenu: *mut nsIAtom; + pub static nsGkAtoms_oncontextmenu: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6oncopyE"] - pub static nsGkAtoms_oncopy: *mut nsIAtom; + pub static nsGkAtoms_oncopy: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23oncurrentchannelchangedE"] - pub static nsGkAtoms_oncurrentchannelchanged: *mut nsIAtom; + pub static nsGkAtoms_oncurrentchannelchanged: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms22oncurrentsourcechangedE"] - pub static nsGkAtoms_oncurrentsourcechanged: *mut nsIAtom; + pub static nsGkAtoms_oncurrentsourcechanged: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5oncutE"] - pub static nsGkAtoms_oncut: *mut nsIAtom; + pub static nsGkAtoms_oncut: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12ondatachangeE"] - pub static nsGkAtoms_ondatachange: *mut nsIAtom; + pub static nsGkAtoms_ondatachange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11ondataerrorE"] - pub static nsGkAtoms_ondataerror: *mut nsIAtom; + pub static nsGkAtoms_ondataerror: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10ondblclickE"] - pub static nsGkAtoms_ondblclick: *mut nsIAtom; + pub static nsGkAtoms_ondblclick: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9ondeletedE"] - pub static nsGkAtoms_ondeleted: *mut nsIAtom; + pub static nsGkAtoms_ondeleted: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17ondeliverysuccessE"] - pub static nsGkAtoms_ondeliverysuccess: *mut nsIAtom; + pub static nsGkAtoms_ondeliverysuccess: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15ondeliveryerrorE"] - pub static nsGkAtoms_ondeliveryerror: *mut nsIAtom; + pub static nsGkAtoms_ondeliveryerror: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13ondevicefoundE"] - pub static nsGkAtoms_ondevicefound: *mut nsIAtom; + pub static nsGkAtoms_ondevicefound: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14ondevicepairedE"] - pub static nsGkAtoms_ondevicepaired: *mut nsIAtom; + pub static nsGkAtoms_ondevicepaired: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16ondeviceunpairedE"] - pub static nsGkAtoms_ondeviceunpaired: *mut nsIAtom; + pub static nsGkAtoms_ondeviceunpaired: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9ondialingE"] - pub static nsGkAtoms_ondialing: *mut nsIAtom; + pub static nsGkAtoms_ondialing: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10ondisabledE"] - pub static nsGkAtoms_ondisabled: *mut nsIAtom; + pub static nsGkAtoms_ondisabled: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23ondischargingtimechangeE"] - pub static nsGkAtoms_ondischargingtimechange: *mut nsIAtom; + pub static nsGkAtoms_ondischargingtimechange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12ondisconnectE"] - pub static nsGkAtoms_ondisconnect: *mut nsIAtom; + pub static nsGkAtoms_ondisconnect: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14ondisconnectedE"] - pub static nsGkAtoms_ondisconnected: *mut nsIAtom; + pub static nsGkAtoms_ondisconnected: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15ondisconnectingE"] - pub static nsGkAtoms_ondisconnecting: *mut nsIAtom; + pub static nsGkAtoms_ondisconnecting: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19ondisplaypasskeyreqE"] - pub static nsGkAtoms_ondisplaypasskeyreq: *mut nsIAtom; + pub static nsGkAtoms_ondisplaypasskeyreq: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13ondownloadingE"] - pub static nsGkAtoms_ondownloading: *mut nsIAtom; + pub static nsGkAtoms_ondownloading: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onDOMActivateE"] - pub static nsGkAtoms_onDOMActivate: *mut nsIAtom; + pub static nsGkAtoms_onDOMActivate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17onDOMAttrModifiedE"] - pub static nsGkAtoms_onDOMAttrModified: *mut nsIAtom; + pub static nsGkAtoms_onDOMAttrModified: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms26onDOMCharacterDataModifiedE"] - pub static nsGkAtoms_onDOMCharacterDataModified: *mut nsIAtom; + pub static nsGkAtoms_onDOMCharacterDataModified: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onDOMFocusInE"] - pub static nsGkAtoms_onDOMFocusIn: *mut nsIAtom; + pub static nsGkAtoms_onDOMFocusIn: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onDOMFocusOutE"] - pub static nsGkAtoms_onDOMFocusOut: *mut nsIAtom; + pub static nsGkAtoms_onDOMFocusOut: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16onDOMMouseScrollE"] - pub static nsGkAtoms_onDOMMouseScroll: *mut nsIAtom; + pub static nsGkAtoms_onDOMMouseScroll: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17onDOMNodeInsertedE"] - pub static nsGkAtoms_onDOMNodeInserted: *mut nsIAtom; + pub static nsGkAtoms_onDOMNodeInserted: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms29onDOMNodeInsertedIntoDocumentE"] - pub static nsGkAtoms_onDOMNodeInsertedIntoDocument: *mut nsIAtom; + pub static nsGkAtoms_onDOMNodeInsertedIntoDocument: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16onDOMNodeRemovedE"] - pub static nsGkAtoms_onDOMNodeRemoved: *mut nsIAtom; + pub static nsGkAtoms_onDOMNodeRemoved: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms28onDOMNodeRemovedFromDocumentE"] - pub static nsGkAtoms_onDOMNodeRemovedFromDocument: *mut nsIAtom; + pub static nsGkAtoms_onDOMNodeRemovedFromDocument: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20onDOMSubtreeModifiedE"] - pub static nsGkAtoms_onDOMSubtreeModified: *mut nsIAtom; + pub static nsGkAtoms_onDOMSubtreeModified: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6ondataE"] - pub static nsGkAtoms_ondata: *mut nsIAtom; + pub static nsGkAtoms_ondata: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6ondragE"] - pub static nsGkAtoms_ondrag: *mut nsIAtom; + pub static nsGkAtoms_ondrag: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10ondragdropE"] - pub static nsGkAtoms_ondragdrop: *mut nsIAtom; + pub static nsGkAtoms_ondragdrop: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9ondragendE"] - pub static nsGkAtoms_ondragend: *mut nsIAtom; + pub static nsGkAtoms_ondragend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11ondragenterE"] - pub static nsGkAtoms_ondragenter: *mut nsIAtom; + pub static nsGkAtoms_ondragenter: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10ondragexitE"] - pub static nsGkAtoms_ondragexit: *mut nsIAtom; + pub static nsGkAtoms_ondragexit: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13ondraggestureE"] - pub static nsGkAtoms_ondraggesture: *mut nsIAtom; + pub static nsGkAtoms_ondraggesture: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11ondragleaveE"] - pub static nsGkAtoms_ondragleave: *mut nsIAtom; + pub static nsGkAtoms_ondragleave: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10ondragoverE"] - pub static nsGkAtoms_ondragover: *mut nsIAtom; + pub static nsGkAtoms_ondragover: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11ondragstartE"] - pub static nsGkAtoms_ondragstart: *mut nsIAtom; + pub static nsGkAtoms_ondragstart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7ondrainE"] - pub static nsGkAtoms_ondrain: *mut nsIAtom; + pub static nsGkAtoms_ondrain: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6ondropE"] - pub static nsGkAtoms_ondrop: *mut nsIAtom; + pub static nsGkAtoms_ondrop: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16oneitbroadcastedE"] - pub static nsGkAtoms_oneitbroadcasted: *mut nsIAtom; + pub static nsGkAtoms_oneitbroadcasted: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onenabledE"] - pub static nsGkAtoms_onenabled: *mut nsIAtom; + pub static nsGkAtoms_onenabled: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17onenterpincodereqE"] - pub static nsGkAtoms_onenterpincodereq: *mut nsIAtom; + pub static nsGkAtoms_onenterpincodereq: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23onemergencycbmodechangeE"] - pub static nsGkAtoms_onemergencycbmodechange: *mut nsIAtom; + pub static nsGkAtoms_onemergencycbmodechange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7onerrorE"] - pub static nsGkAtoms_onerror: *mut nsIAtom; + pub static nsGkAtoms_onerror: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onevictedE"] - pub static nsGkAtoms_onevicted: *mut nsIAtom; + pub static nsGkAtoms_onevicted: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8onfailedE"] - pub static nsGkAtoms_onfailed: *mut nsIAtom; + pub static nsGkAtoms_onfailed: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7onfetchE"] - pub static nsGkAtoms_onfetch: *mut nsIAtom; + pub static nsGkAtoms_onfetch: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8onfinishE"] - pub static nsGkAtoms_onfinish: *mut nsIAtom; + pub static nsGkAtoms_onfinish: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7onfocusE"] - pub static nsGkAtoms_onfocus: *mut nsIAtom; + pub static nsGkAtoms_onfocus: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onfocusinE"] - pub static nsGkAtoms_onfocusin: *mut nsIAtom; + pub static nsGkAtoms_onfocusin: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onfocusoutE"] - pub static nsGkAtoms_onfocusout: *mut nsIAtom; + pub static nsGkAtoms_onfocusout: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17onfrequencychangeE"] - pub static nsGkAtoms_onfrequencychange: *mut nsIAtom; + pub static nsGkAtoms_onfrequencychange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18onfullscreenchangeE"] - pub static nsGkAtoms_onfullscreenchange: *mut nsIAtom; + pub static nsGkAtoms_onfullscreenchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17onfullscreenerrorE"] - pub static nsGkAtoms_onfullscreenerror: *mut nsIAtom; + pub static nsGkAtoms_onfullscreenerror: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21onspeakerforcedchangeE"] - pub static nsGkAtoms_onspeakerforcedchange: *mut nsIAtom; + pub static nsGkAtoms_onspeakerforcedchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5ongetE"] - pub static nsGkAtoms_onget: *mut nsIAtom; + pub static nsGkAtoms_onget: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13ongroupchangeE"] - pub static nsGkAtoms_ongroupchange: *mut nsIAtom; + pub static nsGkAtoms_ongroupchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onhashchangeE"] - pub static nsGkAtoms_onhashchange: *mut nsIAtom; + pub static nsGkAtoms_onhashchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18onheadphoneschangeE"] - pub static nsGkAtoms_onheadphoneschange: *mut nsIAtom; + pub static nsGkAtoms_onheadphoneschange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6onheldE"] - pub static nsGkAtoms_onheld: *mut nsIAtom; + pub static nsGkAtoms_onheld: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18onhfpstatuschangedE"] - pub static nsGkAtoms_onhfpstatuschanged: *mut nsIAtom; + pub static nsGkAtoms_onhfpstatuschanged: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18onhidstatuschangedE"] - pub static nsGkAtoms_onhidstatuschanged: *mut nsIAtom; + pub static nsGkAtoms_onhidstatuschanged: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onholdingE"] - pub static nsGkAtoms_onholding: *mut nsIAtom; + pub static nsGkAtoms_onholding: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11oniccchangeE"] - pub static nsGkAtoms_oniccchange: *mut nsIAtom; + pub static nsGkAtoms_oniccchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13oniccdetectedE"] - pub static nsGkAtoms_oniccdetected: *mut nsIAtom; + pub static nsGkAtoms_oniccdetected: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15oniccinfochangeE"] - pub static nsGkAtoms_oniccinfochange: *mut nsIAtom; + pub static nsGkAtoms_oniccinfochange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15oniccundetectedE"] - pub static nsGkAtoms_oniccundetected: *mut nsIAtom; + pub static nsGkAtoms_oniccundetected: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onincomingE"] - pub static nsGkAtoms_onincoming: *mut nsIAtom; + pub static nsGkAtoms_onincoming: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7oninputE"] - pub static nsGkAtoms_oninput: *mut nsIAtom; + pub static nsGkAtoms_oninput: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9oninstallE"] - pub static nsGkAtoms_oninstall: *mut nsIAtom; + pub static nsGkAtoms_oninstall: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9oninvalidE"] - pub static nsGkAtoms_oninvalid: *mut nsIAtom; + pub static nsGkAtoms_oninvalid: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onkeydownE"] - pub static nsGkAtoms_onkeydown: *mut nsIAtom; + pub static nsGkAtoms_onkeydown: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onkeypressE"] - pub static nsGkAtoms_onkeypress: *mut nsIAtom; + pub static nsGkAtoms_onkeypress: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7onkeyupE"] - pub static nsGkAtoms_onkeyup: *mut nsIAtom; + pub static nsGkAtoms_onkeyup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16onlanguagechangeE"] - pub static nsGkAtoms_onlanguagechange: *mut nsIAtom; + pub static nsGkAtoms_onlanguagechange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onlevelchangeE"] - pub static nsGkAtoms_onlevelchange: *mut nsIAtom; + pub static nsGkAtoms_onlevelchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6onLoadE"] - pub static nsGkAtoms_onLoad: *mut nsIAtom; + pub static nsGkAtoms_onLoad: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6onloadE"] - pub static nsGkAtoms_onload: *mut nsIAtom; + pub static nsGkAtoms_onload: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onloadingE"] - pub static nsGkAtoms_onloading: *mut nsIAtom; + pub static nsGkAtoms_onloading: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onloadingdoneE"] - pub static nsGkAtoms_onloadingdone: *mut nsIAtom; + pub static nsGkAtoms_onloadingdone: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14onloadingerrorE"] - pub static nsGkAtoms_onloadingerror: *mut nsIAtom; + pub static nsGkAtoms_onloadingerror: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onpopstateE"] - pub static nsGkAtoms_onpopstate: *mut nsIAtom; + pub static nsGkAtoms_onpopstate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4onlyE"] - pub static nsGkAtoms_only: *mut nsIAtom; + pub static nsGkAtoms_only: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onmessageE"] - pub static nsGkAtoms_onmessage: *mut nsIAtom; + pub static nsGkAtoms_onmessage: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14onmessageerrorE"] - pub static nsGkAtoms_onmessageerror: *mut nsIAtom; + pub static nsGkAtoms_onmessageerror: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11onmousedownE"] - pub static nsGkAtoms_onmousedown: *mut nsIAtom; + pub static nsGkAtoms_onmousedown: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onmouseenterE"] - pub static nsGkAtoms_onmouseenter: *mut nsIAtom; + pub static nsGkAtoms_onmouseenter: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onmouseleaveE"] - pub static nsGkAtoms_onmouseleave: *mut nsIAtom; + pub static nsGkAtoms_onmouseleave: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14onmouselongtapE"] - pub static nsGkAtoms_onmouselongtap: *mut nsIAtom; + pub static nsGkAtoms_onmouselongtap: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11onmousemoveE"] - pub static nsGkAtoms_onmousemove: *mut nsIAtom; + pub static nsGkAtoms_onmousemove: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onmouseoutE"] - pub static nsGkAtoms_onmouseout: *mut nsIAtom; + pub static nsGkAtoms_onmouseout: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11onmouseoverE"] - pub static nsGkAtoms_onmouseover: *mut nsIAtom; + pub static nsGkAtoms_onmouseover: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17onMozMouseHittestE"] - pub static nsGkAtoms_onMozMouseHittest: *mut nsIAtom; + pub static nsGkAtoms_onMozMouseHittest: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onmouseupE"] - pub static nsGkAtoms_onmouseup: *mut nsIAtom; + pub static nsGkAtoms_onmouseup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15onMozAfterPaintE"] - pub static nsGkAtoms_onMozAfterPaint: *mut nsIAtom; + pub static nsGkAtoms_onMozAfterPaint: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21onmozfullscreenchangeE"] - pub static nsGkAtoms_onmozfullscreenchange: *mut nsIAtom; + pub static nsGkAtoms_onmozfullscreenchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20onmozfullscreenerrorE"] - pub static nsGkAtoms_onmozfullscreenerror: *mut nsIAtom; + pub static nsGkAtoms_onmozfullscreenerror: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20onmozkeydownonpluginE"] - pub static nsGkAtoms_onmozkeydownonplugin: *mut nsIAtom; + pub static nsGkAtoms_onmozkeydownonplugin: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18onmozkeyuponpluginE"] - pub static nsGkAtoms_onmozkeyuponplugin: *mut nsIAtom; + pub static nsGkAtoms_onmozkeyuponplugin: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms22onmozpointerlockchangeE"] - pub static nsGkAtoms_onmozpointerlockchange: *mut nsIAtom; + pub static nsGkAtoms_onmozpointerlockchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21onmozpointerlockerrorE"] - pub static nsGkAtoms_onmozpointerlockerror: *mut nsIAtom; + pub static nsGkAtoms_onmozpointerlockerror: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21onMozMousePixelScrollE"] - pub static nsGkAtoms_onMozMousePixelScroll: *mut nsIAtom; + pub static nsGkAtoms_onMozMousePixelScroll: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24onMozScrolledAreaChangedE"] - pub static nsGkAtoms_onMozScrolledAreaChanged: *mut nsIAtom; + pub static nsGkAtoms_onMozScrolledAreaChanged: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21onmapfolderlistingreqE"] - pub static nsGkAtoms_onmapfolderlistingreq: *mut nsIAtom; + pub static nsGkAtoms_onmapfolderlistingreq: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23onmapmessageslistingreqE"] - pub static nsGkAtoms_onmapmessageslistingreq: *mut nsIAtom; + pub static nsGkAtoms_onmapmessageslistingreq: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18onmapgetmessagereqE"] - pub static nsGkAtoms_onmapgetmessagereq: *mut nsIAtom; + pub static nsGkAtoms_onmapgetmessagereq: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24onmapsetmessagestatusreqE"] - pub static nsGkAtoms_onmapsetmessagestatusreq: *mut nsIAtom; + pub static nsGkAtoms_onmapsetmessagestatusreq: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19onmapsendmessagereqE"] - pub static nsGkAtoms_onmapsendmessagereq: *mut nsIAtom; + pub static nsGkAtoms_onmapsendmessagereq: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21onmapmessageupdatereqE"] - pub static nsGkAtoms_onmapmessageupdatereq: *mut nsIAtom; + pub static nsGkAtoms_onmapmessageupdatereq: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onnewrdsgroupE"] - pub static nsGkAtoms_onnewrdsgroup: *mut nsIAtom; + pub static nsGkAtoms_onnewrdsgroup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19onnotificationclickE"] - pub static nsGkAtoms_onnotificationclick: *mut nsIAtom; + pub static nsGkAtoms_onnotificationclick: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19onnotificationcloseE"] - pub static nsGkAtoms_onnotificationclose: *mut nsIAtom; + pub static nsGkAtoms_onnotificationclose: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onnoupdateE"] - pub static nsGkAtoms_onnoupdate: *mut nsIAtom; + pub static nsGkAtoms_onnoupdate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17onobexpasswordreqE"] - pub static nsGkAtoms_onobexpasswordreq: *mut nsIAtom; + pub static nsGkAtoms_onobexpasswordreq: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onobsoleteE"] - pub static nsGkAtoms_onobsolete: *mut nsIAtom; + pub static nsGkAtoms_onobsolete: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8ononlineE"] - pub static nsGkAtoms_ononline: *mut nsIAtom; + pub static nsGkAtoms_ononline: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onofflineE"] - pub static nsGkAtoms_onoffline: *mut nsIAtom; + pub static nsGkAtoms_onoffline: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6onopenE"] - pub static nsGkAtoms_onopen: *mut nsIAtom; + pub static nsGkAtoms_onopen: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19onorientationchangeE"] - pub static nsGkAtoms_onorientationchange: *mut nsIAtom; + pub static nsGkAtoms_onorientationchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17onotastatuschangeE"] - pub static nsGkAtoms_onotastatuschange: *mut nsIAtom; + pub static nsGkAtoms_onotastatuschange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onoverflowE"] - pub static nsGkAtoms_onoverflow: *mut nsIAtom; + pub static nsGkAtoms_onoverflow: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17onoverflowchangedE"] - pub static nsGkAtoms_onoverflowchanged: *mut nsIAtom; + pub static nsGkAtoms_onoverflowchanged: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onpagehideE"] - pub static nsGkAtoms_onpagehide: *mut nsIAtom; + pub static nsGkAtoms_onpagehide: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onpageshowE"] - pub static nsGkAtoms_onpageshow: *mut nsIAtom; + pub static nsGkAtoms_onpageshow: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7onpaintE"] - pub static nsGkAtoms_onpaint: *mut nsIAtom; + pub static nsGkAtoms_onpaint: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16onpairingabortedE"] - pub static nsGkAtoms_onpairingaborted: *mut nsIAtom; + pub static nsGkAtoms_onpairingaborted: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24onpairingconfirmationreqE"] - pub static nsGkAtoms_onpairingconfirmationreq: *mut nsIAtom; + pub static nsGkAtoms_onpairingconfirmationreq: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19onpairingconsentreqE"] - pub static nsGkAtoms_onpairingconsentreq: *mut nsIAtom; + pub static nsGkAtoms_onpairingconsentreq: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7onpasteE"] - pub static nsGkAtoms_onpaste: *mut nsIAtom; + pub static nsGkAtoms_onpaste: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15onpendingchangeE"] - pub static nsGkAtoms_onpendingchange: *mut nsIAtom; + pub static nsGkAtoms_onpendingchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onpichangeE"] - pub static nsGkAtoms_onpichange: *mut nsIAtom; + pub static nsGkAtoms_onpichange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19onpointerlockchangeE"] - pub static nsGkAtoms_onpointerlockchange: *mut nsIAtom; + pub static nsGkAtoms_onpointerlockchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18onpointerlockerrorE"] - pub static nsGkAtoms_onpointerlockerror: *mut nsIAtom; + pub static nsGkAtoms_onpointerlockerror: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onpopuphiddenE"] - pub static nsGkAtoms_onpopuphidden: *mut nsIAtom; + pub static nsGkAtoms_onpopuphidden: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onpopuphidingE"] - pub static nsGkAtoms_onpopuphiding: *mut nsIAtom; + pub static nsGkAtoms_onpopuphiding: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17onpopuppositionedE"] - pub static nsGkAtoms_onpopuppositioned: *mut nsIAtom; + pub static nsGkAtoms_onpopuppositioned: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14onpopupshowingE"] - pub static nsGkAtoms_onpopupshowing: *mut nsIAtom; + pub static nsGkAtoms_onpopupshowing: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onpopupshownE"] - pub static nsGkAtoms_onpopupshown: *mut nsIAtom; + pub static nsGkAtoms_onpopupshown: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18onpullphonebookreqE"] - pub static nsGkAtoms_onpullphonebookreq: *mut nsIAtom; + pub static nsGkAtoms_onpullphonebookreq: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19onpullvcardentryreqE"] - pub static nsGkAtoms_onpullvcardentryreq: *mut nsIAtom; + pub static nsGkAtoms_onpullvcardentryreq: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21onpullvcardlistingreqE"] - pub static nsGkAtoms_onpullvcardlistingreq: *mut nsIAtom; + pub static nsGkAtoms_onpullvcardlistingreq: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6onpushE"] - pub static nsGkAtoms_onpush: *mut nsIAtom; + pub static nsGkAtoms_onpush: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24onpushsubscriptionchangeE"] - pub static nsGkAtoms_onpushsubscriptionchange: *mut nsIAtom; + pub static nsGkAtoms_onpushsubscriptionchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onpschangeE"] - pub static nsGkAtoms_onpschange: *mut nsIAtom; + pub static nsGkAtoms_onpschange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11onptychangeE"] - pub static nsGkAtoms_onptychange: *mut nsIAtom; + pub static nsGkAtoms_onptychange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18onradiostatechangeE"] - pub static nsGkAtoms_onradiostatechange: *mut nsIAtom; + pub static nsGkAtoms_onradiostatechange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18onRadioStateChangeE"] - pub static nsGkAtoms_onRadioStateChange: *mut nsIAtom; + pub static nsGkAtoms_onRadioStateChange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onrdsdisabledE"] - pub static nsGkAtoms_onrdsdisabled: *mut nsIAtom; + pub static nsGkAtoms_onrdsdisabled: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onrdsenabledE"] - pub static nsGkAtoms_onrdsenabled: *mut nsIAtom; + pub static nsGkAtoms_onrdsenabled: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11onreaderrorE"] - pub static nsGkAtoms_onreaderror: *mut nsIAtom; + pub static nsGkAtoms_onreaderror: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onreadsuccessE"] - pub static nsGkAtoms_onreadsuccess: *mut nsIAtom; + pub static nsGkAtoms_onreadsuccess: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7onreadyE"] - pub static nsGkAtoms_onready: *mut nsIAtom; + pub static nsGkAtoms_onready: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18onreadystatechangeE"] - pub static nsGkAtoms_onreadystatechange: *mut nsIAtom; + pub static nsGkAtoms_onreadystatechange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onreceivedE"] - pub static nsGkAtoms_onreceived: *mut nsIAtom; + pub static nsGkAtoms_onreceived: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onremoteheldE"] - pub static nsGkAtoms_onremoteheld: *mut nsIAtom; + pub static nsGkAtoms_onremoteheld: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15onremoteresumedE"] - pub static nsGkAtoms_onremoteresumed: *mut nsIAtom; + pub static nsGkAtoms_onremoteresumed: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17onrequestprogressE"] - pub static nsGkAtoms_onrequestprogress: *mut nsIAtom; + pub static nsGkAtoms_onrequestprogress: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms26onresourcetimingbufferfullE"] - pub static nsGkAtoms_onresourcetimingbufferfull: *mut nsIAtom; + pub static nsGkAtoms_onresourcetimingbufferfull: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18onresponseprogressE"] - pub static nsGkAtoms_onresponseprogress: *mut nsIAtom; + pub static nsGkAtoms_onresponseprogress: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onretrievingE"] - pub static nsGkAtoms_onretrieving: *mut nsIAtom; + pub static nsGkAtoms_onretrieving: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onRequestE"] - pub static nsGkAtoms_onRequest: *mut nsIAtom; + pub static nsGkAtoms_onRequest: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24onrequestmediaplaystatusE"] - pub static nsGkAtoms_onrequestmediaplaystatus: *mut nsIAtom; + pub static nsGkAtoms_onrequestmediaplaystatus: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7onresetE"] - pub static nsGkAtoms_onreset: *mut nsIAtom; + pub static nsGkAtoms_onreset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onresumingE"] - pub static nsGkAtoms_onresuming: *mut nsIAtom; + pub static nsGkAtoms_onresuming: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8onresizeE"] - pub static nsGkAtoms_onresize: *mut nsIAtom; + pub static nsGkAtoms_onresize: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onrtchangeE"] - pub static nsGkAtoms_onrtchange: *mut nsIAtom; + pub static nsGkAtoms_onrtchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms22onscanningstatechangedE"] - pub static nsGkAtoms_onscanningstatechanged: *mut nsIAtom; + pub static nsGkAtoms_onscanningstatechanged: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18onscostatuschangedE"] - pub static nsGkAtoms_onscostatuschanged: *mut nsIAtom; + pub static nsGkAtoms_onscostatuschanged: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8onscrollE"] - pub static nsGkAtoms_onscroll: *mut nsIAtom; + pub static nsGkAtoms_onscroll: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8onselectE"] - pub static nsGkAtoms_onselect: *mut nsIAtom; + pub static nsGkAtoms_onselect: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17onselectionchangeE"] - pub static nsGkAtoms_onselectionchange: *mut nsIAtom; + pub static nsGkAtoms_onselectionchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onselectstartE"] - pub static nsGkAtoms_onselectstart: *mut nsIAtom; + pub static nsGkAtoms_onselectstart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onsendingE"] - pub static nsGkAtoms_onsending: *mut nsIAtom; + pub static nsGkAtoms_onsending: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6onsentE"] - pub static nsGkAtoms_onsent: *mut nsIAtom; + pub static nsGkAtoms_onsent: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5onsetE"] - pub static nsGkAtoms_onset: *mut nsIAtom; + pub static nsGkAtoms_onset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23onshippingaddresschangeE"] - pub static nsGkAtoms_onshippingaddresschange: *mut nsIAtom; + pub static nsGkAtoms_onshippingaddresschange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms22onshippingoptionchangeE"] - pub static nsGkAtoms_onshippingoptionchange: *mut nsIAtom; + pub static nsGkAtoms_onshippingoptionchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6onshowE"] - pub static nsGkAtoms_onshow: *mut nsIAtom; + pub static nsGkAtoms_onshow: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onstatechangeE"] - pub static nsGkAtoms_onstatechange: *mut nsIAtom; + pub static nsGkAtoms_onstatechange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15onstatuschangedE"] - pub static nsGkAtoms_onstatuschanged: *mut nsIAtom; + pub static nsGkAtoms_onstatuschanged: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onstkcommandE"] - pub static nsGkAtoms_onstkcommand: *mut nsIAtom; + pub static nsGkAtoms_onstkcommand: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15onstksessionendE"] - pub static nsGkAtoms_onstksessionend: *mut nsIAtom; + pub static nsGkAtoms_onstksessionend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onstorageE"] - pub static nsGkAtoms_onstorage: *mut nsIAtom; + pub static nsGkAtoms_onstorage: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20onstorageareachangedE"] - pub static nsGkAtoms_onstorageareachanged: *mut nsIAtom; + pub static nsGkAtoms_onstorageareachanged: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8onsubmitE"] - pub static nsGkAtoms_onsubmit: *mut nsIAtom; + pub static nsGkAtoms_onsubmit: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onsuccessE"] - pub static nsGkAtoms_onsuccess: *mut nsIAtom; + pub static nsGkAtoms_onsuccess: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12ontypechangeE"] - pub static nsGkAtoms_ontypechange: *mut nsIAtom; + pub static nsGkAtoms_ontypechange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11onterminateE"] - pub static nsGkAtoms_onterminate: *mut nsIAtom; + pub static nsGkAtoms_onterminate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6ontextE"] - pub static nsGkAtoms_ontext: *mut nsIAtom; + pub static nsGkAtoms_ontext: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8ontoggleE"] - pub static nsGkAtoms_ontoggle: *mut nsIAtom; + pub static nsGkAtoms_ontoggle: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12ontouchstartE"] - pub static nsGkAtoms_ontouchstart: *mut nsIAtom; + pub static nsGkAtoms_ontouchstart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10ontouchendE"] - pub static nsGkAtoms_ontouchend: *mut nsIAtom; + pub static nsGkAtoms_ontouchend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11ontouchmoveE"] - pub static nsGkAtoms_ontouchmove: *mut nsIAtom; + pub static nsGkAtoms_ontouchmove: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13ontouchcancelE"] - pub static nsGkAtoms_ontouchcancel: *mut nsIAtom; + pub static nsGkAtoms_ontouchcancel: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18ontransitioncancelE"] - pub static nsGkAtoms_ontransitioncancel: *mut nsIAtom; + pub static nsGkAtoms_ontransitioncancel: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15ontransitionendE"] - pub static nsGkAtoms_ontransitionend: *mut nsIAtom; + pub static nsGkAtoms_ontransitionend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15ontransitionrunE"] - pub static nsGkAtoms_ontransitionrun: *mut nsIAtom; + pub static nsGkAtoms_ontransitionrun: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17ontransitionstartE"] - pub static nsGkAtoms_ontransitionstart: *mut nsIAtom; + pub static nsGkAtoms_ontransitionstart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11onunderflowE"] - pub static nsGkAtoms_onunderflow: *mut nsIAtom; + pub static nsGkAtoms_onunderflow: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8onunloadE"] - pub static nsGkAtoms_onunload: *mut nsIAtom; + pub static nsGkAtoms_onunload: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onupdatefoundE"] - pub static nsGkAtoms_onupdatefound: *mut nsIAtom; + pub static nsGkAtoms_onupdatefound: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onupdatereadyE"] - pub static nsGkAtoms_onupdateready: *mut nsIAtom; + pub static nsGkAtoms_onupdateready: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15onupgradeneededE"] - pub static nsGkAtoms_onupgradeneeded: *mut nsIAtom; + pub static nsGkAtoms_onupgradeneeded: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14onussdreceivedE"] - pub static nsGkAtoms_onussdreceived: *mut nsIAtom; + pub static nsGkAtoms_onussdreceived: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15onversionchangeE"] - pub static nsGkAtoms_onversionchange: *mut nsIAtom; + pub static nsGkAtoms_onversionchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18onvisibilitychangeE"] - pub static nsGkAtoms_onvisibilitychange: *mut nsIAtom; + pub static nsGkAtoms_onvisibilitychange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onvoicechangeE"] - pub static nsGkAtoms_onvoicechange: *mut nsIAtom; + pub static nsGkAtoms_onvoicechange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15onvoiceschangedE"] - pub static nsGkAtoms_onvoiceschanged: *mut nsIAtom; + pub static nsGkAtoms_onvoiceschanged: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19onvrdisplayactivateE"] - pub static nsGkAtoms_onvrdisplayactivate: *mut nsIAtom; + pub static nsGkAtoms_onvrdisplayactivate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18onvrdisplayconnectE"] - pub static nsGkAtoms_onvrdisplayconnect: *mut nsIAtom; + pub static nsGkAtoms_onvrdisplayconnect: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21onvrdisplaydeactivateE"] - pub static nsGkAtoms_onvrdisplaydeactivate: *mut nsIAtom; + pub static nsGkAtoms_onvrdisplaydeactivate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21onvrdisplaydisconnectE"] - pub static nsGkAtoms_onvrdisplaydisconnect: *mut nsIAtom; + pub static nsGkAtoms_onvrdisplaydisconnect: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24onvrdisplaypresentchangeE"] - pub static nsGkAtoms_onvrdisplaypresentchange: *mut nsIAtom; + pub static nsGkAtoms_onvrdisplaypresentchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20onwebkitAnimationEndE"] - pub static nsGkAtoms_onwebkitAnimationEnd: *mut nsIAtom; + pub static nsGkAtoms_onwebkitAnimationEnd: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms26onwebkitAnimationIterationE"] - pub static nsGkAtoms_onwebkitAnimationIteration: *mut nsIAtom; + pub static nsGkAtoms_onwebkitAnimationIteration: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms22onwebkitAnimationStartE"] - pub static nsGkAtoms_onwebkitAnimationStart: *mut nsIAtom; + pub static nsGkAtoms_onwebkitAnimationStart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21onwebkitTransitionEndE"] - pub static nsGkAtoms_onwebkitTransitionEnd: *mut nsIAtom; + pub static nsGkAtoms_onwebkitTransitionEnd: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20onwebkitanimationendE"] - pub static nsGkAtoms_onwebkitanimationend: *mut nsIAtom; + pub static nsGkAtoms_onwebkitanimationend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms26onwebkitanimationiterationE"] - pub static nsGkAtoms_onwebkitanimationiteration: *mut nsIAtom; + pub static nsGkAtoms_onwebkitanimationiteration: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms22onwebkitanimationstartE"] - pub static nsGkAtoms_onwebkitanimationstart: *mut nsIAtom; + pub static nsGkAtoms_onwebkitanimationstart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21onwebkittransitionendE"] - pub static nsGkAtoms_onwebkittransitionend: *mut nsIAtom; + pub static nsGkAtoms_onwebkittransitionend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11onwebsocketE"] - pub static nsGkAtoms_onwebsocket: *mut nsIAtom; + pub static nsGkAtoms_onwebsocket: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7onwheelE"] - pub static nsGkAtoms_onwheel: *mut nsIAtom; + pub static nsGkAtoms_onwheel: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4openE"] - pub static nsGkAtoms_open: *mut nsIAtom; + pub static nsGkAtoms_open: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8optgroupE"] - pub static nsGkAtoms_optgroup: *mut nsIAtom; + pub static nsGkAtoms_optgroup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7optimumE"] - pub static nsGkAtoms_optimum: *mut nsIAtom; + pub static nsGkAtoms_optimum: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6optionE"] - pub static nsGkAtoms_option: *mut nsIAtom; + pub static nsGkAtoms_option: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3_orE"] - pub static nsGkAtoms__or: *mut nsIAtom; + pub static nsGkAtoms__or: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5orderE"] - pub static nsGkAtoms_order: *mut nsIAtom; + pub static nsGkAtoms_order: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7ordinalE"] - pub static nsGkAtoms_ordinal: *mut nsIAtom; + pub static nsGkAtoms_ordinal: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6orientE"] - pub static nsGkAtoms_orient: *mut nsIAtom; + pub static nsGkAtoms_orient: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11orientationE"] - pub static nsGkAtoms_orientation: *mut nsIAtom; + pub static nsGkAtoms_orientation: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9otherwiseE"] - pub static nsGkAtoms_otherwise: *mut nsIAtom; + pub static nsGkAtoms_otherwise: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6outputE"] - pub static nsGkAtoms_output: *mut nsIAtom; + pub static nsGkAtoms_output: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8overflowE"] - pub static nsGkAtoms_overflow: *mut nsIAtom; + pub static nsGkAtoms_overflow: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15overflowchangedE"] - pub static nsGkAtoms_overflowchanged: *mut nsIAtom; + pub static nsGkAtoms_overflowchanged: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7overlayE"] - pub static nsGkAtoms_overlay: *mut nsIAtom; + pub static nsGkAtoms_overlay: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7overlapE"] - pub static nsGkAtoms_overlap: *mut nsIAtom; + pub static nsGkAtoms_overlap: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms1pE"] - pub static nsGkAtoms_p: *mut nsIAtom; + pub static nsGkAtoms_p: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4packE"] - pub static nsGkAtoms_pack: *mut nsIAtom; + pub static nsGkAtoms_pack: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4pageE"] - pub static nsGkAtoms_page: *mut nsIAtom; + pub static nsGkAtoms_page: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13pageincrementE"] - pub static nsGkAtoms_pageincrement: *mut nsIAtom; + pub static nsGkAtoms_pageincrement: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5pagexE"] - pub static nsGkAtoms_pagex: *mut nsIAtom; + pub static nsGkAtoms_pagex: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5pageyE"] - pub static nsGkAtoms_pagey: *mut nsIAtom; + pub static nsGkAtoms_pagey: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11paint_orderE"] - pub static nsGkAtoms_paint_order: *mut nsIAtom; + pub static nsGkAtoms_paint_order: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11palettenameE"] - pub static nsGkAtoms_palettename: *mut nsIAtom; + pub static nsGkAtoms_palettename: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5panelE"] - pub static nsGkAtoms_panel: *mut nsIAtom; + pub static nsGkAtoms_panel: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5paramE"] - pub static nsGkAtoms_param: *mut nsIAtom; + pub static nsGkAtoms_param: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9parameterE"] - pub static nsGkAtoms_parameter: *mut nsIAtom; + pub static nsGkAtoms_parameter: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6parentE"] - pub static nsGkAtoms_parent: *mut nsIAtom; + pub static nsGkAtoms_parent: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13parentfocusedE"] - pub static nsGkAtoms_parentfocused: *mut nsIAtom; + pub static nsGkAtoms_parentfocused: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9parsetypeE"] - pub static nsGkAtoms_parsetype: *mut nsIAtom; + pub static nsGkAtoms_parsetype: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8passwordE"] - pub static nsGkAtoms_password: *mut nsIAtom; + pub static nsGkAtoms_password: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7patternE"] - pub static nsGkAtoms_pattern: *mut nsIAtom; + pub static nsGkAtoms_pattern: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16patternSeparatorE"] - pub static nsGkAtoms_patternSeparator: *mut nsIAtom; + pub static nsGkAtoms_patternSeparator: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8perMilleE"] - pub static nsGkAtoms_perMille: *mut nsIAtom; + pub static nsGkAtoms_perMille: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7percentE"] - pub static nsGkAtoms_percent: *mut nsIAtom; + pub static nsGkAtoms_percent: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7persistE"] - pub static nsGkAtoms_persist: *mut nsIAtom; + pub static nsGkAtoms_persist: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5phaseE"] - pub static nsGkAtoms_phase: *mut nsIAtom; + pub static nsGkAtoms_phase: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7pictureE"] - pub static nsGkAtoms_picture: *mut nsIAtom; + pub static nsGkAtoms_picture: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4pingE"] - pub static nsGkAtoms_ping: *mut nsIAtom; + pub static nsGkAtoms_ping: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6pinnedE"] - pub static nsGkAtoms_pinned: *mut nsIAtom; + pub static nsGkAtoms_pinned: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11placeholderE"] - pub static nsGkAtoms_placeholder: *mut nsIAtom; + pub static nsGkAtoms_placeholder: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9plaintextE"] - pub static nsGkAtoms_plaintext: *mut nsIAtom; + pub static nsGkAtoms_plaintext: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12playbackrateE"] - pub static nsGkAtoms_playbackrate: *mut nsIAtom; + pub static nsGkAtoms_playbackrate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9pointSizeE"] - pub static nsGkAtoms_pointSize: *mut nsIAtom; + pub static nsGkAtoms_pointSize: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17pointerlockchangeE"] - pub static nsGkAtoms_pointerlockchange: *mut nsIAtom; + pub static nsGkAtoms_pointerlockchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16pointerlockerrorE"] - pub static nsGkAtoms_pointerlockerror: *mut nsIAtom; + pub static nsGkAtoms_pointerlockerror: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4polyE"] - pub static nsGkAtoms_poly: *mut nsIAtom; + pub static nsGkAtoms_poly: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7polygonE"] - pub static nsGkAtoms_polygon: *mut nsIAtom; + pub static nsGkAtoms_polygon: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5popupE"] - pub static nsGkAtoms_popup: *mut nsIAtom; + pub static nsGkAtoms_popup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10popupalignE"] - pub static nsGkAtoms_popupalign: *mut nsIAtom; + pub static nsGkAtoms_popupalign: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11popupanchorE"] - pub static nsGkAtoms_popupanchor: *mut nsIAtom; + pub static nsGkAtoms_popupanchor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10popupgroupE"] - pub static nsGkAtoms_popupgroup: *mut nsIAtom; + pub static nsGkAtoms_popupgroup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11popuphiddenE"] - pub static nsGkAtoms_popuphidden: *mut nsIAtom; + pub static nsGkAtoms_popuphidden: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11popuphidingE"] - pub static nsGkAtoms_popuphiding: *mut nsIAtom; + pub static nsGkAtoms_popuphiding: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8popupsetE"] - pub static nsGkAtoms_popupset: *mut nsIAtom; + pub static nsGkAtoms_popupset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12popupshowingE"] - pub static nsGkAtoms_popupshowing: *mut nsIAtom; + pub static nsGkAtoms_popupshowing: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10popupshownE"] - pub static nsGkAtoms_popupshown: *mut nsIAtom; + pub static nsGkAtoms_popupshown: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20popupsinherittooltipE"] - pub static nsGkAtoms_popupsinherittooltip: *mut nsIAtom; + pub static nsGkAtoms_popupsinherittooltip: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8positionE"] - pub static nsGkAtoms_position: *mut nsIAtom; + pub static nsGkAtoms_position: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6posterE"] - pub static nsGkAtoms_poster: *mut nsIAtom; + pub static nsGkAtoms_poster: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3preE"] - pub static nsGkAtoms_pre: *mut nsIAtom; + pub static nsGkAtoms_pre: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9precedingE"] - pub static nsGkAtoms_preceding: *mut nsIAtom; + pub static nsGkAtoms_preceding: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16precedingSiblingE"] - pub static nsGkAtoms_precedingSibling: *mut nsIAtom; + pub static nsGkAtoms_precedingSibling: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9predicateE"] - pub static nsGkAtoms_predicate: *mut nsIAtom; + pub static nsGkAtoms_predicate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6prefixE"] - pub static nsGkAtoms_prefix: *mut nsIAtom; + pub static nsGkAtoms_prefix: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7preloadE"] - pub static nsGkAtoms_preload: *mut nsIAtom; + pub static nsGkAtoms_preload: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11prerenderedE"] - pub static nsGkAtoms_prerendered: *mut nsIAtom; + pub static nsGkAtoms_prerendered: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15mozpresentationE"] - pub static nsGkAtoms_mozpresentation: *mut nsIAtom; + pub static nsGkAtoms_mozpresentation: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8preserveE"] - pub static nsGkAtoms_preserve: *mut nsIAtom; + pub static nsGkAtoms_preserve: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13preserveSpaceE"] - pub static nsGkAtoms_preserveSpace: *mut nsIAtom; + pub static nsGkAtoms_preserveSpace: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14preventdefaultE"] - pub static nsGkAtoms_preventdefault: *mut nsIAtom; + pub static nsGkAtoms_preventdefault: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7primaryE"] - pub static nsGkAtoms_primary: *mut nsIAtom; + pub static nsGkAtoms_primary: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5printE"] - pub static nsGkAtoms_print: *mut nsIAtom; + pub static nsGkAtoms_print: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8priorityE"] - pub static nsGkAtoms_priority: *mut nsIAtom; + pub static nsGkAtoms_priority: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21processingInstructionE"] - pub static nsGkAtoms_processingInstruction: *mut nsIAtom; + pub static nsGkAtoms_processingInstruction: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7profileE"] - pub static nsGkAtoms_profile: *mut nsIAtom; + pub static nsGkAtoms_profile: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8progressE"] - pub static nsGkAtoms_progress: *mut nsIAtom; + pub static nsGkAtoms_progress: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13progressmeterE"] - pub static nsGkAtoms_progressmeter: *mut nsIAtom; + pub static nsGkAtoms_progressmeter: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14progressNormalE"] - pub static nsGkAtoms_progressNormal: *mut nsIAtom; + pub static nsGkAtoms_progressNormal: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20progressUndeterminedE"] - pub static nsGkAtoms_progressUndetermined: *mut nsIAtom; + pub static nsGkAtoms_progressUndetermined: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10projectionE"] - pub static nsGkAtoms_projection: *mut nsIAtom; + pub static nsGkAtoms_projection: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6promptE"] - pub static nsGkAtoms_prompt: *mut nsIAtom; + pub static nsGkAtoms_prompt: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9propagateE"] - pub static nsGkAtoms_propagate: *mut nsIAtom; + pub static nsGkAtoms_propagate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10propertiesE"] - pub static nsGkAtoms_properties: *mut nsIAtom; + pub static nsGkAtoms_properties: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8propertyE"] - pub static nsGkAtoms_property: *mut nsIAtom; + pub static nsGkAtoms_property: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7pubdateE"] - pub static nsGkAtoms_pubdate: *mut nsIAtom; + pub static nsGkAtoms_pubdate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms1qE"] - pub static nsGkAtoms_q: *mut nsIAtom; + pub static nsGkAtoms_q: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5queryE"] - pub static nsGkAtoms_query: *mut nsIAtom; + pub static nsGkAtoms_query: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8querysetE"] - pub static nsGkAtoms_queryset: *mut nsIAtom; + pub static nsGkAtoms_queryset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9querytypeE"] - pub static nsGkAtoms_querytype: *mut nsIAtom; + pub static nsGkAtoms_querytype: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5radioE"] - pub static nsGkAtoms_radio: *mut nsIAtom; + pub static nsGkAtoms_radio: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10radiogroupE"] - pub static nsGkAtoms_radiogroup: *mut nsIAtom; + pub static nsGkAtoms_radiogroup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5rangeE"] - pub static nsGkAtoms_range: *mut nsIAtom; + pub static nsGkAtoms_range: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8readonlyE"] - pub static nsGkAtoms_readonly: *mut nsIAtom; + pub static nsGkAtoms_readonly: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4rectE"] - pub static nsGkAtoms_rect: *mut nsIAtom; + pub static nsGkAtoms_rect: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9rectangleE"] - pub static nsGkAtoms_rectangle: *mut nsIAtom; + pub static nsGkAtoms_rectangle: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3refE"] - pub static nsGkAtoms_ref: *mut nsIAtom; + pub static nsGkAtoms_ref: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7refreshE"] - pub static nsGkAtoms_refresh: *mut nsIAtom; + pub static nsGkAtoms_refresh: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3relE"] - pub static nsGkAtoms_rel: *mut nsIAtom; + pub static nsGkAtoms_rel: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onreloadpageE"] - pub static nsGkAtoms_onreloadpage: *mut nsIAtom; + pub static nsGkAtoms_onreloadpage: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3remE"] - pub static nsGkAtoms_rem: *mut nsIAtom; + pub static nsGkAtoms_rem: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6remoteE"] - pub static nsGkAtoms_remote: *mut nsIAtom; + pub static nsGkAtoms_remote: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13removeelementE"] - pub static nsGkAtoms_removeelement: *mut nsIAtom; + pub static nsGkAtoms_removeelement: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21renderingobserverlistE"] - pub static nsGkAtoms_renderingobserverlist: *mut nsIAtom; + pub static nsGkAtoms_renderingobserverlist: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6repeatE"] - pub static nsGkAtoms_repeat: *mut nsIAtom; + pub static nsGkAtoms_repeat: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7replaceE"] - pub static nsGkAtoms_replace: *mut nsIAtom; + pub static nsGkAtoms_replace: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16requestcontextidE"] - pub static nsGkAtoms_requestcontextid: *mut nsIAtom; + pub static nsGkAtoms_requestcontextid: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8requiredE"] - pub static nsGkAtoms_required: *mut nsIAtom; + pub static nsGkAtoms_required: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8reservedE"] - pub static nsGkAtoms_reserved: *mut nsIAtom; + pub static nsGkAtoms_reserved: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5resetE"] - pub static nsGkAtoms_reset: *mut nsIAtom; + pub static nsGkAtoms_reset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11resizeafterE"] - pub static nsGkAtoms_resizeafter: *mut nsIAtom; + pub static nsGkAtoms_resizeafter: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12resizebeforeE"] - pub static nsGkAtoms_resizebefore: *mut nsIAtom; + pub static nsGkAtoms_resizebefore: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7resizerE"] - pub static nsGkAtoms_resizer: *mut nsIAtom; + pub static nsGkAtoms_resizer: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10resolutionE"] - pub static nsGkAtoms_resolution: *mut nsIAtom; + pub static nsGkAtoms_resolution: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8resourceE"] - pub static nsGkAtoms_resource: *mut nsIAtom; + pub static nsGkAtoms_resource: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9resourcesE"] - pub static nsGkAtoms_resources: *mut nsIAtom; + pub static nsGkAtoms_resources: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6resultE"] - pub static nsGkAtoms_result: *mut nsIAtom; + pub static nsGkAtoms_result: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12resultPrefixE"] - pub static nsGkAtoms_resultPrefix: *mut nsIAtom; + pub static nsGkAtoms_resultPrefix: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21retargetdocumentfocusE"] - pub static nsGkAtoms_retargetdocumentfocus: *mut nsIAtom; + pub static nsGkAtoms_retargetdocumentfocus: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3revE"] - pub static nsGkAtoms_rev: *mut nsIAtom; + pub static nsGkAtoms_rev: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7reverseE"] - pub static nsGkAtoms_reverse: *mut nsIAtom; + pub static nsGkAtoms_reverse: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8reversedE"] - pub static nsGkAtoms_reversed: *mut nsIAtom; + pub static nsGkAtoms_reversed: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11richlistboxE"] - pub static nsGkAtoms_richlistbox: *mut nsIAtom; + pub static nsGkAtoms_richlistbox: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12richlistitemE"] - pub static nsGkAtoms_richlistitem: *mut nsIAtom; + pub static nsGkAtoms_richlistitem: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5rightE"] - pub static nsGkAtoms_right: *mut nsIAtom; + pub static nsGkAtoms_right: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11rightmarginE"] - pub static nsGkAtoms_rightmargin: *mut nsIAtom; + pub static nsGkAtoms_rightmargin: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12rightpaddingE"] - pub static nsGkAtoms_rightpadding: *mut nsIAtom; + pub static nsGkAtoms_rightpadding: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4roleE"] - pub static nsGkAtoms_role: *mut nsIAtom; + pub static nsGkAtoms_role: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18rolluponmousewheelE"] - pub static nsGkAtoms_rolluponmousewheel: *mut nsIAtom; + pub static nsGkAtoms_rolluponmousewheel: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5roundE"] - pub static nsGkAtoms_round: *mut nsIAtom; + pub static nsGkAtoms_round: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3rowE"] - pub static nsGkAtoms_row: *mut nsIAtom; + pub static nsGkAtoms_row: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4rowsE"] - pub static nsGkAtoms_rows: *mut nsIAtom; + pub static nsGkAtoms_rows: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7rowspanE"] - pub static nsGkAtoms_rowspan: *mut nsIAtom; + pub static nsGkAtoms_rowspan: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2rbE"] - pub static nsGkAtoms_rb: *mut nsIAtom; + pub static nsGkAtoms_rb: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2rpE"] - pub static nsGkAtoms_rp: *mut nsIAtom; + pub static nsGkAtoms_rp: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2rtE"] - pub static nsGkAtoms_rt: *mut nsIAtom; + pub static nsGkAtoms_rt: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3rtcE"] - pub static nsGkAtoms_rtc: *mut nsIAtom; + pub static nsGkAtoms_rtc: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3rtlE"] - pub static nsGkAtoms_rtl: *mut nsIAtom; + pub static nsGkAtoms_rtl: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4rubyE"] - pub static nsGkAtoms_ruby: *mut nsIAtom; + pub static nsGkAtoms_ruby: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8rubyBaseE"] - pub static nsGkAtoms_rubyBase: *mut nsIAtom; + pub static nsGkAtoms_rubyBase: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17rubyBaseContainerE"] - pub static nsGkAtoms_rubyBaseContainer: *mut nsIAtom; + pub static nsGkAtoms_rubyBaseContainer: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8rubyTextE"] - pub static nsGkAtoms_rubyText: *mut nsIAtom; + pub static nsGkAtoms_rubyText: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17rubyTextContainerE"] - pub static nsGkAtoms_rubyTextContainer: *mut nsIAtom; + pub static nsGkAtoms_rubyTextContainer: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4ruleE"] - pub static nsGkAtoms_rule: *mut nsIAtom; + pub static nsGkAtoms_rule: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5rulesE"] - pub static nsGkAtoms_rules: *mut nsIAtom; + pub static nsGkAtoms_rules: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms1sE"] - pub static nsGkAtoms_s: *mut nsIAtom; + pub static nsGkAtoms_s: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4sampE"] - pub static nsGkAtoms_samp: *mut nsIAtom; + pub static nsGkAtoms_samp: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7sandboxE"] - pub static nsGkAtoms_sandbox: *mut nsIAtom; + pub static nsGkAtoms_sandbox: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6sbattrE"] - pub static nsGkAtoms_sbattr: *mut nsIAtom; + pub static nsGkAtoms_sbattr: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5scaleE"] - pub static nsGkAtoms_scale: *mut nsIAtom; + pub static nsGkAtoms_scale: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4scanE"] - pub static nsGkAtoms_scan: *mut nsIAtom; + pub static nsGkAtoms_scan: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6schemeE"] - pub static nsGkAtoms_scheme: *mut nsIAtom; + pub static nsGkAtoms_scheme: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5scopeE"] - pub static nsGkAtoms_scope: *mut nsIAtom; + pub static nsGkAtoms_scope: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6scopedE"] - pub static nsGkAtoms_scoped: *mut nsIAtom; + pub static nsGkAtoms_scoped: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6screenE"] - pub static nsGkAtoms_screen: *mut nsIAtom; + pub static nsGkAtoms_screen: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7screenXE"] - pub static nsGkAtoms_screenX: *mut nsIAtom; + pub static nsGkAtoms_screenX: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7screenYE"] - pub static nsGkAtoms_screenY: *mut nsIAtom; + pub static nsGkAtoms_screenY: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6scriptE"] - pub static nsGkAtoms_script: *mut nsIAtom; + pub static nsGkAtoms_script: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms33scriptEnabledBeforePrintOrPreviewE"] - pub static nsGkAtoms_scriptEnabledBeforePrintOrPreview: *mut nsIAtom; + pub static nsGkAtoms_scriptEnabledBeforePrintOrPreview: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9scrollbarE"] - pub static nsGkAtoms_scrollbar: *mut nsIAtom; + pub static nsGkAtoms_scrollbar: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15scrollbarbuttonE"] - pub static nsGkAtoms_scrollbarbutton: *mut nsIAtom; + pub static nsGkAtoms_scrollbarbutton: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19scrollbarDownBottomE"] - pub static nsGkAtoms_scrollbarDownBottom: *mut nsIAtom; + pub static nsGkAtoms_scrollbarDownBottom: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16scrollbarDownTopE"] - pub static nsGkAtoms_scrollbarDownTop: *mut nsIAtom; + pub static nsGkAtoms_scrollbarDownTop: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17scrollbarUpBottomE"] - pub static nsGkAtoms_scrollbarUpBottom: *mut nsIAtom; + pub static nsGkAtoms_scrollbarUpBottom: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14scrollbarUpTopE"] - pub static nsGkAtoms_scrollbarUpTop: *mut nsIAtom; + pub static nsGkAtoms_scrollbarUpTop: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9scrollboxE"] - pub static nsGkAtoms_scrollbox: *mut nsIAtom; + pub static nsGkAtoms_scrollbox: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12scrollcornerE"] - pub static nsGkAtoms_scrollcorner: *mut nsIAtom; + pub static nsGkAtoms_scrollcorner: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9scrollingE"] - pub static nsGkAtoms_scrolling: *mut nsIAtom; + pub static nsGkAtoms_scrolling: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14scrollPositionE"] - pub static nsGkAtoms_scrollPosition: *mut nsIAtom; + pub static nsGkAtoms_scrollPosition: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7sectionE"] - pub static nsGkAtoms_section: *mut nsIAtom; + pub static nsGkAtoms_section: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6selectE"] - pub static nsGkAtoms_select: *mut nsIAtom; + pub static nsGkAtoms_select: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10selectableE"] - pub static nsGkAtoms_selectable: *mut nsIAtom; + pub static nsGkAtoms_selectable: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8selectedE"] - pub static nsGkAtoms_selected: *mut nsIAtom; + pub static nsGkAtoms_selected: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13selectedIndexE"] - pub static nsGkAtoms_selectedIndex: *mut nsIAtom; + pub static nsGkAtoms_selectedIndex: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13selectedindexE"] - pub static nsGkAtoms_selectedindex: *mut nsIAtom; + pub static nsGkAtoms_selectedindex: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4selfE"] - pub static nsGkAtoms_self: *mut nsIAtom; + pub static nsGkAtoms_self: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7seltypeE"] - pub static nsGkAtoms_seltype: *mut nsIAtom; + pub static nsGkAtoms_seltype: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9setcookieE"] - pub static nsGkAtoms_setcookie: *mut nsIAtom; + pub static nsGkAtoms_setcookie: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6setterE"] - pub static nsGkAtoms_setter: *mut nsIAtom; + pub static nsGkAtoms_setter: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5shapeE"] - pub static nsGkAtoms_shape: *mut nsIAtom; + pub static nsGkAtoms_shape: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4showE"] - pub static nsGkAtoms_show: *mut nsIAtom; + pub static nsGkAtoms_show: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9showcaretE"] - pub static nsGkAtoms_showcaret: *mut nsIAtom; + pub static nsGkAtoms_showcaret: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11showresizerE"] - pub static nsGkAtoms_showresizer: *mut nsIAtom; + pub static nsGkAtoms_showresizer: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6simpleE"] - pub static nsGkAtoms_simple: *mut nsIAtom; + pub static nsGkAtoms_simple: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19simp_chinese_formalE"] - pub static nsGkAtoms_simp_chinese_formal: *mut nsIAtom; + pub static nsGkAtoms_simp_chinese_formal: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21simp_chinese_informalE"] - pub static nsGkAtoms_simp_chinese_informal: *mut nsIAtom; + pub static nsGkAtoms_simp_chinese_informal: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6singleE"] - pub static nsGkAtoms_single: *mut nsIAtom; + pub static nsGkAtoms_single: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4sizeE"] - pub static nsGkAtoms_size: *mut nsIAtom; + pub static nsGkAtoms_size: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5sizesE"] - pub static nsGkAtoms_sizes: *mut nsIAtom; + pub static nsGkAtoms_sizes: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8sizemodeE"] - pub static nsGkAtoms_sizemode: *mut nsIAtom; + pub static nsGkAtoms_sizemode: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11sizetopopupE"] - pub static nsGkAtoms_sizetopopup: *mut nsIAtom; + pub static nsGkAtoms_sizetopopup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6sliderE"] - pub static nsGkAtoms_slider: *mut nsIAtom; + pub static nsGkAtoms_slider: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5smallE"] - pub static nsGkAtoms_small: *mut nsIAtom; + pub static nsGkAtoms_small: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6smoothE"] - pub static nsGkAtoms_smooth: *mut nsIAtom; + pub static nsGkAtoms_smooth: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4snapE"] - pub static nsGkAtoms_snap: *mut nsIAtom; + pub static nsGkAtoms_snap: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4sortE"] - pub static nsGkAtoms_sort: *mut nsIAtom; + pub static nsGkAtoms_sort: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10sortActiveE"] - pub static nsGkAtoms_sortActive: *mut nsIAtom; + pub static nsGkAtoms_sortActive: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13sortDirectionE"] - pub static nsGkAtoms_sortDirection: *mut nsIAtom; + pub static nsGkAtoms_sortDirection: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6sortedE"] - pub static nsGkAtoms_sorted: *mut nsIAtom; + pub static nsGkAtoms_sorted: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9sorthintsE"] - pub static nsGkAtoms_sorthints: *mut nsIAtom; + pub static nsGkAtoms_sorthints: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10sortLockedE"] - pub static nsGkAtoms_sortLocked: *mut nsIAtom; + pub static nsGkAtoms_sortLocked: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12sortResourceE"] - pub static nsGkAtoms_sortResource: *mut nsIAtom; + pub static nsGkAtoms_sortResource: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13sortResource2E"] - pub static nsGkAtoms_sortResource2: *mut nsIAtom; + pub static nsGkAtoms_sortResource2: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14sortSeparatorsE"] - pub static nsGkAtoms_sortSeparators: *mut nsIAtom; + pub static nsGkAtoms_sortSeparators: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15sortStaticsLastE"] - pub static nsGkAtoms_sortStaticsLast: *mut nsIAtom; + pub static nsGkAtoms_sortStaticsLast: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6sourceE"] - pub static nsGkAtoms_source: *mut nsIAtom; + pub static nsGkAtoms_source: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5spaceE"] - pub static nsGkAtoms_space: *mut nsIAtom; + pub static nsGkAtoms_space: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6spacerE"] - pub static nsGkAtoms_spacer: *mut nsIAtom; + pub static nsGkAtoms_spacer: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4spanE"] - pub static nsGkAtoms_span: *mut nsIAtom; + pub static nsGkAtoms_span: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10spellcheckE"] - pub static nsGkAtoms_spellcheck: *mut nsIAtom; + pub static nsGkAtoms_spellcheck: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7spinnerE"] - pub static nsGkAtoms_spinner: *mut nsIAtom; + pub static nsGkAtoms_spinner: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5splitE"] - pub static nsGkAtoms_split: *mut nsIAtom; + pub static nsGkAtoms_split: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8splitterE"] - pub static nsGkAtoms_splitter: *mut nsIAtom; + pub static nsGkAtoms_splitter: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6springE"] - pub static nsGkAtoms_spring: *mut nsIAtom; + pub static nsGkAtoms_spring: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6squareE"] - pub static nsGkAtoms_square: *mut nsIAtom; + pub static nsGkAtoms_square: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3srcE"] - pub static nsGkAtoms_src: *mut nsIAtom; + pub static nsGkAtoms_src: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6srcdocE"] - pub static nsGkAtoms_srcdoc: *mut nsIAtom; + pub static nsGkAtoms_srcdoc: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7srclangE"] - pub static nsGkAtoms_srclang: *mut nsIAtom; + pub static nsGkAtoms_srclang: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6srcsetE"] - pub static nsGkAtoms_srcset: *mut nsIAtom; + pub static nsGkAtoms_srcset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5stackE"] - pub static nsGkAtoms_stack: *mut nsIAtom; + pub static nsGkAtoms_stack: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10standaloneE"] - pub static nsGkAtoms_standalone: *mut nsIAtom; + pub static nsGkAtoms_standalone: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7standbyE"] - pub static nsGkAtoms_standby: *mut nsIAtom; + pub static nsGkAtoms_standby: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5startE"] - pub static nsGkAtoms_start: *mut nsIAtom; + pub static nsGkAtoms_start: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11start_afterE"] - pub static nsGkAtoms_start_after: *mut nsIAtom; + pub static nsGkAtoms_start_after: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12start_beforeE"] - pub static nsGkAtoms_start_before: *mut nsIAtom; + pub static nsGkAtoms_start_before: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10startsWithE"] - pub static nsGkAtoms_startsWith: *mut nsIAtom; + pub static nsGkAtoms_startsWith: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5stateE"] - pub static nsGkAtoms_state: *mut nsIAtom; + pub static nsGkAtoms_state: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15statedatasourceE"] - pub static nsGkAtoms_statedatasource: *mut nsIAtom; + pub static nsGkAtoms_statedatasource: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10staticHintE"] - pub static nsGkAtoms_staticHint: *mut nsIAtom; + pub static nsGkAtoms_staticHint: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9statusbarE"] - pub static nsGkAtoms_statusbar: *mut nsIAtom; + pub static nsGkAtoms_statusbar: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10statustextE"] - pub static nsGkAtoms_statustext: *mut nsIAtom; + pub static nsGkAtoms_statustext: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4stepE"] - pub static nsGkAtoms_step: *mut nsIAtom; + pub static nsGkAtoms_step: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4stopE"] - pub static nsGkAtoms_stop: *mut nsIAtom; + pub static nsGkAtoms_stop: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7stretchE"] - pub static nsGkAtoms_stretch: *mut nsIAtom; + pub static nsGkAtoms_stretch: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6strikeE"] - pub static nsGkAtoms_strike: *mut nsIAtom; + pub static nsGkAtoms_strike: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6stringE"] - pub static nsGkAtoms_string: *mut nsIAtom; + pub static nsGkAtoms_string: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12stringLengthE"] - pub static nsGkAtoms_stringLength: *mut nsIAtom; + pub static nsGkAtoms_stringLength: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10stripSpaceE"] - pub static nsGkAtoms_stripSpace: *mut nsIAtom; + pub static nsGkAtoms_stripSpace: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6strongE"] - pub static nsGkAtoms_strong: *mut nsIAtom; + pub static nsGkAtoms_strong: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5styleE"] - pub static nsGkAtoms_style: *mut nsIAtom; + pub static nsGkAtoms_style: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10stylesheetE"] - pub static nsGkAtoms_stylesheet: *mut nsIAtom; + pub static nsGkAtoms_stylesheet: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16stylesheetPrefixE"] - pub static nsGkAtoms_stylesheetPrefix: *mut nsIAtom; + pub static nsGkAtoms_stylesheetPrefix: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7subjectE"] - pub static nsGkAtoms_subject: *mut nsIAtom; + pub static nsGkAtoms_subject: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6submitE"] - pub static nsGkAtoms_submit: *mut nsIAtom; + pub static nsGkAtoms_submit: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8substateE"] - pub static nsGkAtoms_substate: *mut nsIAtom; + pub static nsGkAtoms_substate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9substringE"] - pub static nsGkAtoms_substring: *mut nsIAtom; + pub static nsGkAtoms_substring: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14substringAfterE"] - pub static nsGkAtoms_substringAfter: *mut nsIAtom; + pub static nsGkAtoms_substringAfter: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15substringBeforeE"] - pub static nsGkAtoms_substringBefore: *mut nsIAtom; + pub static nsGkAtoms_substringBefore: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3subE"] - pub static nsGkAtoms_sub: *mut nsIAtom; + pub static nsGkAtoms_sub: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3sumE"] - pub static nsGkAtoms_sum: *mut nsIAtom; + pub static nsGkAtoms_sum: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3supE"] - pub static nsGkAtoms_sup: *mut nsIAtom; + pub static nsGkAtoms_sup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7summaryE"] - pub static nsGkAtoms_summary: *mut nsIAtom; + pub static nsGkAtoms_summary: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7_switchE"] - pub static nsGkAtoms__switch: *mut nsIAtom; + pub static nsGkAtoms__switch: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14systemPropertyE"] - pub static nsGkAtoms_systemProperty: *mut nsIAtom; + pub static nsGkAtoms_systemProperty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3tabE"] - pub static nsGkAtoms_tab: *mut nsIAtom; + pub static nsGkAtoms_tab: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6tabboxE"] - pub static nsGkAtoms_tabbox: *mut nsIAtom; + pub static nsGkAtoms_tabbox: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8tabindexE"] - pub static nsGkAtoms_tabindex: *mut nsIAtom; + pub static nsGkAtoms_tabindex: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5tableE"] - pub static nsGkAtoms_table: *mut nsIAtom; + pub static nsGkAtoms_table: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8tabpanelE"] - pub static nsGkAtoms_tabpanel: *mut nsIAtom; + pub static nsGkAtoms_tabpanel: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9tabpanelsE"] - pub static nsGkAtoms_tabpanels: *mut nsIAtom; + pub static nsGkAtoms_tabpanels: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3tagE"] - pub static nsGkAtoms_tag: *mut nsIAtom; + pub static nsGkAtoms_tag: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6targetE"] - pub static nsGkAtoms_target: *mut nsIAtom; + pub static nsGkAtoms_target: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7targetsE"] - pub static nsGkAtoms_targets: *mut nsIAtom; + pub static nsGkAtoms_targets: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5tbodyE"] - pub static nsGkAtoms_tbody: *mut nsIAtom; + pub static nsGkAtoms_tbody: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2tdE"] - pub static nsGkAtoms_td: *mut nsIAtom; + pub static nsGkAtoms_td: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9_templateE"] - pub static nsGkAtoms__template: *mut nsIAtom; + pub static nsGkAtoms__template: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15text_decorationE"] - pub static nsGkAtoms_text_decoration: *mut nsIAtom; + pub static nsGkAtoms_text_decoration: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9terminateE"] - pub static nsGkAtoms_terminate: *mut nsIAtom; + pub static nsGkAtoms_terminate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4termE"] - pub static nsGkAtoms_term: *mut nsIAtom; + pub static nsGkAtoms_term: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4testE"] - pub static nsGkAtoms_test: *mut nsIAtom; + pub static nsGkAtoms_test: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4textE"] - pub static nsGkAtoms_text: *mut nsIAtom; + pub static nsGkAtoms_text: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9textAlignE"] - pub static nsGkAtoms_textAlign: *mut nsIAtom; + pub static nsGkAtoms_textAlign: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8textareaE"] - pub static nsGkAtoms_textarea: *mut nsIAtom; + pub static nsGkAtoms_textarea: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7textboxE"] - pub static nsGkAtoms_textbox: *mut nsIAtom; + pub static nsGkAtoms_textbox: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8textnodeE"] - pub static nsGkAtoms_textnode: *mut nsIAtom; + pub static nsGkAtoms_textnode: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms25textNodeDirectionalityMapE"] - pub static nsGkAtoms_textNodeDirectionalityMap: *mut nsIAtom; + pub static nsGkAtoms_textNodeDirectionalityMap: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5tfootE"] - pub static nsGkAtoms_tfoot: *mut nsIAtom; + pub static nsGkAtoms_tfoot: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2thE"] - pub static nsGkAtoms_th: *mut nsIAtom; + pub static nsGkAtoms_th: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5theadE"] - pub static nsGkAtoms_thead: *mut nsIAtom; + pub static nsGkAtoms_thead: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5thumbE"] - pub static nsGkAtoms_thumb: *mut nsIAtom; + pub static nsGkAtoms_thumb: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4timeE"] - pub static nsGkAtoms_time: *mut nsIAtom; + pub static nsGkAtoms_time: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5titleE"] - pub static nsGkAtoms_title: *mut nsIAtom; + pub static nsGkAtoms_title: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8titlebarE"] - pub static nsGkAtoms_titlebar: *mut nsIAtom; + pub static nsGkAtoms_titlebar: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8titletipE"] - pub static nsGkAtoms_titletip: *mut nsIAtom; + pub static nsGkAtoms_titletip: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7toggledE"] - pub static nsGkAtoms_toggled: *mut nsIAtom; + pub static nsGkAtoms_toggled: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5tokenE"] - pub static nsGkAtoms_token: *mut nsIAtom; + pub static nsGkAtoms_token: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8tokenizeE"] - pub static nsGkAtoms_tokenize: *mut nsIAtom; + pub static nsGkAtoms_tokenize: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7toolbarE"] - pub static nsGkAtoms_toolbar: *mut nsIAtom; + pub static nsGkAtoms_toolbar: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13toolbarbuttonE"] - pub static nsGkAtoms_toolbarbutton: *mut nsIAtom; + pub static nsGkAtoms_toolbarbutton: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11toolbaritemE"] - pub static nsGkAtoms_toolbaritem: *mut nsIAtom; + pub static nsGkAtoms_toolbaritem: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7toolboxE"] - pub static nsGkAtoms_toolbox: *mut nsIAtom; + pub static nsGkAtoms_toolbox: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7tooltipE"] - pub static nsGkAtoms_tooltip: *mut nsIAtom; + pub static nsGkAtoms_tooltip: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11tooltiptextE"] - pub static nsGkAtoms_tooltiptext: *mut nsIAtom; + pub static nsGkAtoms_tooltiptext: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3topE"] - pub static nsGkAtoms_top: *mut nsIAtom; + pub static nsGkAtoms_top: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7topleftE"] - pub static nsGkAtoms_topleft: *mut nsIAtom; + pub static nsGkAtoms_topleft: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9topmarginE"] - pub static nsGkAtoms_topmargin: *mut nsIAtom; + pub static nsGkAtoms_topmargin: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10toppaddingE"] - pub static nsGkAtoms_toppadding: *mut nsIAtom; + pub static nsGkAtoms_toppadding: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8toprightE"] - pub static nsGkAtoms_topright: *mut nsIAtom; + pub static nsGkAtoms_topright: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2trE"] - pub static nsGkAtoms_tr: *mut nsIAtom; + pub static nsGkAtoms_tr: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5trackE"] - pub static nsGkAtoms_track: *mut nsIAtom; + pub static nsGkAtoms_track: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19trad_chinese_formalE"] - pub static nsGkAtoms_trad_chinese_formal: *mut nsIAtom; + pub static nsGkAtoms_trad_chinese_formal: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21trad_chinese_informalE"] - pub static nsGkAtoms_trad_chinese_informal: *mut nsIAtom; + pub static nsGkAtoms_trad_chinese_informal: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8trailingE"] - pub static nsGkAtoms_trailing: *mut nsIAtom; + pub static nsGkAtoms_trailing: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9transformE"] - pub static nsGkAtoms_transform: *mut nsIAtom; + pub static nsGkAtoms_transform: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12transform_3dE"] - pub static nsGkAtoms_transform_3d: *mut nsIAtom; + pub static nsGkAtoms_transform_3d: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12transformiixE"] - pub static nsGkAtoms_transformiix: *mut nsIAtom; + pub static nsGkAtoms_transformiix: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9translateE"] - pub static nsGkAtoms_translate: *mut nsIAtom; + pub static nsGkAtoms_translate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11transparentE"] - pub static nsGkAtoms_transparent: *mut nsIAtom; + pub static nsGkAtoms_transparent: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4treeE"] - pub static nsGkAtoms_tree: *mut nsIAtom; + pub static nsGkAtoms_tree: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8treecellE"] - pub static nsGkAtoms_treecell: *mut nsIAtom; + pub static nsGkAtoms_treecell: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12treechildrenE"] - pub static nsGkAtoms_treechildren: *mut nsIAtom; + pub static nsGkAtoms_treechildren: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7treecolE"] - pub static nsGkAtoms_treecol: *mut nsIAtom; + pub static nsGkAtoms_treecol: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13treecolpickerE"] - pub static nsGkAtoms_treecolpicker: *mut nsIAtom; + pub static nsGkAtoms_treecolpicker: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8treecolsE"] - pub static nsGkAtoms_treecols: *mut nsIAtom; + pub static nsGkAtoms_treecols: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8treeitemE"] - pub static nsGkAtoms_treeitem: *mut nsIAtom; + pub static nsGkAtoms_treeitem: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7treerowE"] - pub static nsGkAtoms_treerow: *mut nsIAtom; + pub static nsGkAtoms_treerow: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13treeseparatorE"] - pub static nsGkAtoms_treeseparator: *mut nsIAtom; + pub static nsGkAtoms_treeseparator: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6tripleE"] - pub static nsGkAtoms_triple: *mut nsIAtom; + pub static nsGkAtoms_triple: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5_trueE"] - pub static nsGkAtoms__true: *mut nsIAtom; + pub static nsGkAtoms__true: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2ttE"] - pub static nsGkAtoms_tt: *mut nsIAtom; + pub static nsGkAtoms_tt: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3ttyE"] - pub static nsGkAtoms_tty: *mut nsIAtom; + pub static nsGkAtoms_tty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2tvE"] - pub static nsGkAtoms_tv: *mut nsIAtom; + pub static nsGkAtoms_tv: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4typeE"] - pub static nsGkAtoms_type: *mut nsIAtom; + pub static nsGkAtoms_type: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13typemustmatchE"] - pub static nsGkAtoms_typemustmatch: *mut nsIAtom; + pub static nsGkAtoms_typemustmatch: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms1uE"] - pub static nsGkAtoms_u: *mut nsIAtom; + pub static nsGkAtoms_u: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2ulE"] - pub static nsGkAtoms_ul: *mut nsIAtom; + pub static nsGkAtoms_ul: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9underflowE"] - pub static nsGkAtoms_underflow: *mut nsIAtom; + pub static nsGkAtoms_underflow: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12undeterminedE"] - pub static nsGkAtoms_undetermined: *mut nsIAtom; + pub static nsGkAtoms_undetermined: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6unloadE"] - pub static nsGkAtoms_unload: *mut nsIAtom; + pub static nsGkAtoms_unload: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17unparsedEntityUriE"] - pub static nsGkAtoms_unparsedEntityUri: *mut nsIAtom; + pub static nsGkAtoms_unparsedEntityUri: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10upperAlphaE"] - pub static nsGkAtoms_upperAlpha: *mut nsIAtom; + pub static nsGkAtoms_upperAlpha: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10upperFirstE"] - pub static nsGkAtoms_upperFirst: *mut nsIAtom; + pub static nsGkAtoms_upperFirst: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10upperRomanE"] - pub static nsGkAtoms_upperRoman: *mut nsIAtom; + pub static nsGkAtoms_upperRoman: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3uriE"] - pub static nsGkAtoms_uri: *mut nsIAtom; + pub static nsGkAtoms_uri: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3useE"] - pub static nsGkAtoms_use: *mut nsIAtom; + pub static nsGkAtoms_use: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16useAttributeSetsE"] - pub static nsGkAtoms_useAttributeSets: *mut nsIAtom; + pub static nsGkAtoms_useAttributeSets: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6usemapE"] - pub static nsGkAtoms_usemap: *mut nsIAtom; + pub static nsGkAtoms_usemap: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13user_scalableE"] - pub static nsGkAtoms_user_scalable: *mut nsIAtom; + pub static nsGkAtoms_user_scalable: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9userInputE"] - pub static nsGkAtoms_userInput: *mut nsIAtom; + pub static nsGkAtoms_userInput: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8validateE"] - pub static nsGkAtoms_validate: *mut nsIAtom; + pub static nsGkAtoms_validate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6valignE"] - pub static nsGkAtoms_valign: *mut nsIAtom; + pub static nsGkAtoms_valign: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5valueE"] - pub static nsGkAtoms_value: *mut nsIAtom; + pub static nsGkAtoms_value: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6valuesE"] - pub static nsGkAtoms_values: *mut nsIAtom; + pub static nsGkAtoms_values: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7valueOfE"] - pub static nsGkAtoms_valueOf: *mut nsIAtom; + pub static nsGkAtoms_valueOf: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9valuetypeE"] - pub static nsGkAtoms_valuetype: *mut nsIAtom; + pub static nsGkAtoms_valuetype: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3varE"] - pub static nsGkAtoms_var: *mut nsIAtom; + pub static nsGkAtoms_var: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8variableE"] - pub static nsGkAtoms_variable: *mut nsIAtom; + pub static nsGkAtoms_variable: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4vboxE"] - pub static nsGkAtoms_vbox: *mut nsIAtom; + pub static nsGkAtoms_vbox: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10vcard_nameE"] - pub static nsGkAtoms_vcard_name: *mut nsIAtom; + pub static nsGkAtoms_vcard_name: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6vendorE"] - pub static nsGkAtoms_vendor: *mut nsIAtom; + pub static nsGkAtoms_vendor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9vendorUrlE"] - pub static nsGkAtoms_vendorUrl: *mut nsIAtom; + pub static nsGkAtoms_vendorUrl: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7versionE"] - pub static nsGkAtoms_version: *mut nsIAtom; + pub static nsGkAtoms_version: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4vertE"] - pub static nsGkAtoms_vert: *mut nsIAtom; + pub static nsGkAtoms_vert: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8verticalE"] - pub static nsGkAtoms_vertical: *mut nsIAtom; + pub static nsGkAtoms_vertical: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5audioE"] - pub static nsGkAtoms_audio: *mut nsIAtom; + pub static nsGkAtoms_audio: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5videoE"] - pub static nsGkAtoms_video: *mut nsIAtom; + pub static nsGkAtoms_video: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13videocontrolsE"] - pub static nsGkAtoms_videocontrols: *mut nsIAtom; + pub static nsGkAtoms_videocontrols: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8viewportE"] - pub static nsGkAtoms_viewport: *mut nsIAtom; + pub static nsGkAtoms_viewport: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15viewport_heightE"] - pub static nsGkAtoms_viewport_height: *mut nsIAtom; + pub static nsGkAtoms_viewport_height: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms22viewport_initial_scaleE"] - pub static nsGkAtoms_viewport_initial_scale: *mut nsIAtom; + pub static nsGkAtoms_viewport_initial_scale: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms22viewport_maximum_scaleE"] - pub static nsGkAtoms_viewport_maximum_scale: *mut nsIAtom; + pub static nsGkAtoms_viewport_maximum_scale: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms22viewport_minimum_scaleE"] - pub static nsGkAtoms_viewport_minimum_scale: *mut nsIAtom; + pub static nsGkAtoms_viewport_minimum_scale: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms22viewport_user_scalableE"] - pub static nsGkAtoms_viewport_user_scalable: *mut nsIAtom; + pub static nsGkAtoms_viewport_user_scalable: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14viewport_widthE"] - pub static nsGkAtoms_viewport_width: *mut nsIAtom; + pub static nsGkAtoms_viewport_width: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10visibilityE"] - pub static nsGkAtoms_visibility: *mut nsIAtom; + pub static nsGkAtoms_visibility: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16visuallyselectedE"] - pub static nsGkAtoms_visuallyselected: *mut nsIAtom; + pub static nsGkAtoms_visuallyselected: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5vlinkE"] - pub static nsGkAtoms_vlink: *mut nsIAtom; + pub static nsGkAtoms_vlink: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6vspaceE"] - pub static nsGkAtoms_vspace: *mut nsIAtom; + pub static nsGkAtoms_vspace: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3wbrE"] - pub static nsGkAtoms_wbr: *mut nsIAtom; + pub static nsGkAtoms_wbr: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15webkitdirectoryE"] - pub static nsGkAtoms_webkitdirectory: *mut nsIAtom; + pub static nsGkAtoms_webkitdirectory: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4whenE"] - pub static nsGkAtoms_when: *mut nsIAtom; + pub static nsGkAtoms_when: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5whereE"] - pub static nsGkAtoms_where: *mut nsIAtom; + pub static nsGkAtoms_where: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6widgetE"] - pub static nsGkAtoms_widget: *mut nsIAtom; + pub static nsGkAtoms_widget: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5widthE"] - pub static nsGkAtoms_width: *mut nsIAtom; + pub static nsGkAtoms_width: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10willChangeE"] - pub static nsGkAtoms_willChange: *mut nsIAtom; + pub static nsGkAtoms_willChange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6windowE"] - pub static nsGkAtoms_window: *mut nsIAtom; + pub static nsGkAtoms_window: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18headerWindowTargetE"] - pub static nsGkAtoms_headerWindowTarget: *mut nsIAtom; + pub static nsGkAtoms_headerWindowTarget: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10windowtypeE"] - pub static nsGkAtoms_windowtype: *mut nsIAtom; + pub static nsGkAtoms_windowtype: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9withParamE"] - pub static nsGkAtoms_withParam: *mut nsIAtom; + pub static nsGkAtoms_withParam: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6wizardE"] - pub static nsGkAtoms_wizard: *mut nsIAtom; + pub static nsGkAtoms_wizard: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4wrapE"] - pub static nsGkAtoms_wrap: *mut nsIAtom; + pub static nsGkAtoms_wrap: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24headerDNSPrefetchControlE"] - pub static nsGkAtoms_headerDNSPrefetchControl: *mut nsIAtom; + pub static nsGkAtoms_headerDNSPrefetchControl: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9headerCSPE"] - pub static nsGkAtoms_headerCSP: *mut nsIAtom; + pub static nsGkAtoms_headerCSP: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19headerCSPReportOnlyE"] - pub static nsGkAtoms_headerCSPReportOnly: *mut nsIAtom; + pub static nsGkAtoms_headerCSPReportOnly: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9headerXFOE"] - pub static nsGkAtoms_headerXFO: *mut nsIAtom; + pub static nsGkAtoms_headerXFO: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9x_westernE"] - pub static nsGkAtoms_x_western: *mut nsIAtom; + pub static nsGkAtoms_x_western: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3xmlE"] - pub static nsGkAtoms_xml: *mut nsIAtom; + pub static nsGkAtoms_xml: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14xml_stylesheetE"] - pub static nsGkAtoms_xml_stylesheet: *mut nsIAtom; + pub static nsGkAtoms_xml_stylesheet: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5xmlnsE"] - pub static nsGkAtoms_xmlns: *mut nsIAtom; + pub static nsGkAtoms_xmlns: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3xmpE"] - pub static nsGkAtoms_xmp: *mut nsIAtom; + pub static nsGkAtoms_xmp: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20xulcontentsgeneratedE"] - pub static nsGkAtoms_xulcontentsgenerated: *mut nsIAtom; + pub static nsGkAtoms_xulcontentsgenerated: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3yesE"] - pub static nsGkAtoms_yes: *mut nsIAtom; + pub static nsGkAtoms_yes: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7z_indexE"] - pub static nsGkAtoms_z_index: *mut nsIAtom; + pub static nsGkAtoms_z_index: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9zeroDigitE"] - pub static nsGkAtoms_zeroDigit: *mut nsIAtom; + pub static nsGkAtoms_zeroDigit: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10percentageE"] - pub static nsGkAtoms_percentage: *mut nsIAtom; + pub static nsGkAtoms_percentage: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms1AE"] - pub static nsGkAtoms_A: *mut nsIAtom; + pub static nsGkAtoms_A: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18alignment_baselineE"] - pub static nsGkAtoms_alignment_baseline: *mut nsIAtom; + pub static nsGkAtoms_alignment_baseline: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9amplitudeE"] - pub static nsGkAtoms_amplitude: *mut nsIAtom; + pub static nsGkAtoms_amplitude: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7animateE"] - pub static nsGkAtoms_animate: *mut nsIAtom; + pub static nsGkAtoms_animate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12animateColorE"] - pub static nsGkAtoms_animateColor: *mut nsIAtom; + pub static nsGkAtoms_animateColor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13animateMotionE"] - pub static nsGkAtoms_animateMotion: *mut nsIAtom; + pub static nsGkAtoms_animateMotion: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16animateTransformE"] - pub static nsGkAtoms_animateTransform: *mut nsIAtom; + pub static nsGkAtoms_animateTransform: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10arithmeticE"] - pub static nsGkAtoms_arithmetic: *mut nsIAtom; + pub static nsGkAtoms_arithmetic: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4atopE"] - pub static nsGkAtoms_atop: *mut nsIAtom; + pub static nsGkAtoms_atop: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7azimuthE"] - pub static nsGkAtoms_azimuth: *mut nsIAtom; + pub static nsGkAtoms_azimuth: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms1BE"] - pub static nsGkAtoms_B: *mut nsIAtom; + pub static nsGkAtoms_B: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15backgroundColorE"] - pub static nsGkAtoms_backgroundColor: *mut nsIAtom; + pub static nsGkAtoms_backgroundColor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16background_imageE"] - pub static nsGkAtoms_background_image: *mut nsIAtom; + pub static nsGkAtoms_background_image: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13baseFrequencyE"] - pub static nsGkAtoms_baseFrequency: *mut nsIAtom; + pub static nsGkAtoms_baseFrequency: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14baseline_shiftE"] - pub static nsGkAtoms_baseline_shift: *mut nsIAtom; + pub static nsGkAtoms_baseline_shift: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4biasE"] - pub static nsGkAtoms_bias: *mut nsIAtom; + pub static nsGkAtoms_bias: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12caption_sideE"] - pub static nsGkAtoms_caption_side: *mut nsIAtom; + pub static nsGkAtoms_caption_side: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9clip_pathE"] - pub static nsGkAtoms_clip_path: *mut nsIAtom; + pub static nsGkAtoms_clip_path: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9clip_ruleE"] - pub static nsGkAtoms_clip_rule: *mut nsIAtom; + pub static nsGkAtoms_clip_rule: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8clipPathE"] - pub static nsGkAtoms_clipPath: *mut nsIAtom; + pub static nsGkAtoms_clipPath: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13clipPathUnitsE"] - pub static nsGkAtoms_clipPathUnits: *mut nsIAtom; + pub static nsGkAtoms_clipPathUnits: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2cmE"] - pub static nsGkAtoms_cm: *mut nsIAtom; + pub static nsGkAtoms_cm: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9colorBurnE"] - pub static nsGkAtoms_colorBurn: *mut nsIAtom; + pub static nsGkAtoms_colorBurn: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10colorDodgeE"] - pub static nsGkAtoms_colorDodge: *mut nsIAtom; + pub static nsGkAtoms_colorDodge: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18colorInterpolationE"] - pub static nsGkAtoms_colorInterpolation: *mut nsIAtom; + pub static nsGkAtoms_colorInterpolation: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms25colorInterpolationFiltersE"] - pub static nsGkAtoms_colorInterpolationFilters: *mut nsIAtom; + pub static nsGkAtoms_colorInterpolationFilters: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12colorProfileE"] - pub static nsGkAtoms_colorProfile: *mut nsIAtom; + pub static nsGkAtoms_colorProfile: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6cursorE"] - pub static nsGkAtoms_cursor: *mut nsIAtom; + pub static nsGkAtoms_cursor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2cxE"] - pub static nsGkAtoms_cx: *mut nsIAtom; + pub static nsGkAtoms_cx: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2cyE"] - pub static nsGkAtoms_cy: *mut nsIAtom; + pub static nsGkAtoms_cy: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms1dE"] - pub static nsGkAtoms_d: *mut nsIAtom; + pub static nsGkAtoms_d: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6darkenE"] - pub static nsGkAtoms_darken: *mut nsIAtom; + pub static nsGkAtoms_darken: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4defsE"] - pub static nsGkAtoms_defs: *mut nsIAtom; + pub static nsGkAtoms_defs: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3degE"] - pub static nsGkAtoms_deg: *mut nsIAtom; + pub static nsGkAtoms_deg: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4descE"] - pub static nsGkAtoms_desc: *mut nsIAtom; + pub static nsGkAtoms_desc: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15diffuseConstantE"] - pub static nsGkAtoms_diffuseConstant: *mut nsIAtom; + pub static nsGkAtoms_diffuseConstant: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6dilateE"] - pub static nsGkAtoms_dilate: *mut nsIAtom; + pub static nsGkAtoms_dilate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9directionE"] - pub static nsGkAtoms_direction: *mut nsIAtom; + pub static nsGkAtoms_direction: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7disableE"] - pub static nsGkAtoms_disable: *mut nsIAtom; + pub static nsGkAtoms_disable: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4discE"] - pub static nsGkAtoms_disc: *mut nsIAtom; + pub static nsGkAtoms_disc: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8discreteE"] - pub static nsGkAtoms_discrete: *mut nsIAtom; + pub static nsGkAtoms_discrete: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7divisorE"] - pub static nsGkAtoms_divisor: *mut nsIAtom; + pub static nsGkAtoms_divisor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17dominant_baselineE"] - pub static nsGkAtoms_dominant_baseline: *mut nsIAtom; + pub static nsGkAtoms_dominant_baseline: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9duplicateE"] - pub static nsGkAtoms_duplicate: *mut nsIAtom; + pub static nsGkAtoms_duplicate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2dxE"] - pub static nsGkAtoms_dx: *mut nsIAtom; + pub static nsGkAtoms_dx: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2dyE"] - pub static nsGkAtoms_dy: *mut nsIAtom; + pub static nsGkAtoms_dy: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8edgeModeE"] - pub static nsGkAtoms_edgeMode: *mut nsIAtom; + pub static nsGkAtoms_edgeMode: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7ellipseE"] - pub static nsGkAtoms_ellipse: *mut nsIAtom; + pub static nsGkAtoms_ellipse: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9elevationE"] - pub static nsGkAtoms_elevation: *mut nsIAtom; + pub static nsGkAtoms_elevation: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5erodeE"] - pub static nsGkAtoms_erode: *mut nsIAtom; + pub static nsGkAtoms_erode: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2exE"] - pub static nsGkAtoms_ex: *mut nsIAtom; + pub static nsGkAtoms_ex: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5exactE"] - pub static nsGkAtoms_exact: *mut nsIAtom; + pub static nsGkAtoms_exact: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9exclusionE"] - pub static nsGkAtoms_exclusion: *mut nsIAtom; + pub static nsGkAtoms_exclusion: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8exponentE"] - pub static nsGkAtoms_exponent: *mut nsIAtom; + pub static nsGkAtoms_exponent: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7feBlendE"] - pub static nsGkAtoms_feBlend: *mut nsIAtom; + pub static nsGkAtoms_feBlend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13feColorMatrixE"] - pub static nsGkAtoms_feColorMatrix: *mut nsIAtom; + pub static nsGkAtoms_feColorMatrix: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19feComponentTransferE"] - pub static nsGkAtoms_feComponentTransfer: *mut nsIAtom; + pub static nsGkAtoms_feComponentTransfer: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11feCompositeE"] - pub static nsGkAtoms_feComposite: *mut nsIAtom; + pub static nsGkAtoms_feComposite: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16feConvolveMatrixE"] - pub static nsGkAtoms_feConvolveMatrix: *mut nsIAtom; + pub static nsGkAtoms_feConvolveMatrix: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17feDiffuseLightingE"] - pub static nsGkAtoms_feDiffuseLighting: *mut nsIAtom; + pub static nsGkAtoms_feDiffuseLighting: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17feDisplacementMapE"] - pub static nsGkAtoms_feDisplacementMap: *mut nsIAtom; + pub static nsGkAtoms_feDisplacementMap: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14feDistantLightE"] - pub static nsGkAtoms_feDistantLight: *mut nsIAtom; + pub static nsGkAtoms_feDistantLight: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12feDropShadowE"] - pub static nsGkAtoms_feDropShadow: *mut nsIAtom; + pub static nsGkAtoms_feDropShadow: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7feFloodE"] - pub static nsGkAtoms_feFlood: *mut nsIAtom; + pub static nsGkAtoms_feFlood: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7feFuncAE"] - pub static nsGkAtoms_feFuncA: *mut nsIAtom; + pub static nsGkAtoms_feFuncA: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7feFuncBE"] - pub static nsGkAtoms_feFuncB: *mut nsIAtom; + pub static nsGkAtoms_feFuncB: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7feFuncGE"] - pub static nsGkAtoms_feFuncG: *mut nsIAtom; + pub static nsGkAtoms_feFuncG: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7feFuncRE"] - pub static nsGkAtoms_feFuncR: *mut nsIAtom; + pub static nsGkAtoms_feFuncR: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14feGaussianBlurE"] - pub static nsGkAtoms_feGaussianBlur: *mut nsIAtom; + pub static nsGkAtoms_feGaussianBlur: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7feImageE"] - pub static nsGkAtoms_feImage: *mut nsIAtom; + pub static nsGkAtoms_feImage: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7feMergeE"] - pub static nsGkAtoms_feMerge: *mut nsIAtom; + pub static nsGkAtoms_feMerge: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11feMergeNodeE"] - pub static nsGkAtoms_feMergeNode: *mut nsIAtom; + pub static nsGkAtoms_feMergeNode: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12feMorphologyE"] - pub static nsGkAtoms_feMorphology: *mut nsIAtom; + pub static nsGkAtoms_feMorphology: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8feOffsetE"] - pub static nsGkAtoms_feOffset: *mut nsIAtom; + pub static nsGkAtoms_feOffset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12fePointLightE"] - pub static nsGkAtoms_fePointLight: *mut nsIAtom; + pub static nsGkAtoms_fePointLight: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18feSpecularLightingE"] - pub static nsGkAtoms_feSpecularLighting: *mut nsIAtom; + pub static nsGkAtoms_feSpecularLighting: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11feSpotLightE"] - pub static nsGkAtoms_feSpotLight: *mut nsIAtom; + pub static nsGkAtoms_feSpotLight: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6feTileE"] - pub static nsGkAtoms_feTile: *mut nsIAtom; + pub static nsGkAtoms_feTile: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12feTurbulenceE"] - pub static nsGkAtoms_feTurbulence: *mut nsIAtom; + pub static nsGkAtoms_feTurbulence: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4fillE"] - pub static nsGkAtoms_fill: *mut nsIAtom; + pub static nsGkAtoms_fill: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12fill_opacityE"] - pub static nsGkAtoms_fill_opacity: *mut nsIAtom; + pub static nsGkAtoms_fill_opacity: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9fill_ruleE"] - pub static nsGkAtoms_fill_rule: *mut nsIAtom; + pub static nsGkAtoms_fill_rule: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6filterE"] - pub static nsGkAtoms_filter: *mut nsIAtom; + pub static nsGkAtoms_filter: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11filterUnitsE"] - pub static nsGkAtoms_filterUnits: *mut nsIAtom; + pub static nsGkAtoms_filterUnits: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6_floatE"] - pub static nsGkAtoms__float: *mut nsIAtom; + pub static nsGkAtoms__float: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11flood_colorE"] - pub static nsGkAtoms_flood_color: *mut nsIAtom; + pub static nsGkAtoms_flood_color: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13flood_opacityE"] - pub static nsGkAtoms_flood_opacity: *mut nsIAtom; + pub static nsGkAtoms_flood_opacity: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9font_faceE"] - pub static nsGkAtoms_font_face: *mut nsIAtom; + pub static nsGkAtoms_font_face: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16font_face_formatE"] - pub static nsGkAtoms_font_face_format: *mut nsIAtom; + pub static nsGkAtoms_font_face_format: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14font_face_nameE"] - pub static nsGkAtoms_font_face_name: *mut nsIAtom; + pub static nsGkAtoms_font_face_name: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13font_face_srcE"] - pub static nsGkAtoms_font_face_src: *mut nsIAtom; + pub static nsGkAtoms_font_face_src: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13font_face_uriE"] - pub static nsGkAtoms_font_face_uri: *mut nsIAtom; + pub static nsGkAtoms_font_face_uri: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11font_familyE"] - pub static nsGkAtoms_font_family: *mut nsIAtom; + pub static nsGkAtoms_font_family: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9font_sizeE"] - pub static nsGkAtoms_font_size: *mut nsIAtom; + pub static nsGkAtoms_font_size: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16font_size_adjustE"] - pub static nsGkAtoms_font_size_adjust: *mut nsIAtom; + pub static nsGkAtoms_font_size_adjust: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12font_stretchE"] - pub static nsGkAtoms_font_stretch: *mut nsIAtom; + pub static nsGkAtoms_font_stretch: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10font_styleE"] - pub static nsGkAtoms_font_style: *mut nsIAtom; + pub static nsGkAtoms_font_style: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12font_variantE"] - pub static nsGkAtoms_font_variant: *mut nsIAtom; + pub static nsGkAtoms_font_variant: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13foreignObjectE"] - pub static nsGkAtoms_foreignObject: *mut nsIAtom; + pub static nsGkAtoms_foreignObject: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12fractalNoiseE"] - pub static nsGkAtoms_fractalNoise: *mut nsIAtom; + pub static nsGkAtoms_fractalNoise: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2frE"] - pub static nsGkAtoms_fr: *mut nsIAtom; + pub static nsGkAtoms_fr: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2fxE"] - pub static nsGkAtoms_fx: *mut nsIAtom; + pub static nsGkAtoms_fx: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2fyE"] - pub static nsGkAtoms_fy: *mut nsIAtom; + pub static nsGkAtoms_fy: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms1GE"] - pub static nsGkAtoms_G: *mut nsIAtom; + pub static nsGkAtoms_G: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms1gE"] - pub static nsGkAtoms_g: *mut nsIAtom; + pub static nsGkAtoms_g: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5gammaE"] - pub static nsGkAtoms_gamma: *mut nsIAtom; + pub static nsGkAtoms_gamma: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8generic_E"] - pub static nsGkAtoms_generic_: *mut nsIAtom; + pub static nsGkAtoms_generic_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8glyphRefE"] - pub static nsGkAtoms_glyphRef: *mut nsIAtom; + pub static nsGkAtoms_glyphRef: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4gradE"] - pub static nsGkAtoms_grad: *mut nsIAtom; + pub static nsGkAtoms_grad: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17gradientTransformE"] - pub static nsGkAtoms_gradientTransform: *mut nsIAtom; + pub static nsGkAtoms_gradientTransform: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13gradientUnitsE"] - pub static nsGkAtoms_gradientUnits: *mut nsIAtom; + pub static nsGkAtoms_gradientUnits: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9hardLightE"] - pub static nsGkAtoms_hardLight: *mut nsIAtom; + pub static nsGkAtoms_hardLight: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3hueE"] - pub static nsGkAtoms_hue: *mut nsIAtom; + pub static nsGkAtoms_hue: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9hueRotateE"] - pub static nsGkAtoms_hueRotate: *mut nsIAtom; + pub static nsGkAtoms_hueRotate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8identityE"] - pub static nsGkAtoms_identity: *mut nsIAtom; + pub static nsGkAtoms_identity: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15image_renderingE"] - pub static nsGkAtoms_image_rendering: *mut nsIAtom; + pub static nsGkAtoms_image_rendering: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2inE"] - pub static nsGkAtoms_in: *mut nsIAtom; + pub static nsGkAtoms_in: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3in2E"] - pub static nsGkAtoms_in2: *mut nsIAtom; + pub static nsGkAtoms_in2: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9interceptE"] - pub static nsGkAtoms_intercept: *mut nsIAtom; + pub static nsGkAtoms_intercept: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2k1E"] - pub static nsGkAtoms_k1: *mut nsIAtom; + pub static nsGkAtoms_k1: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2k2E"] - pub static nsGkAtoms_k2: *mut nsIAtom; + pub static nsGkAtoms_k2: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2k3E"] - pub static nsGkAtoms_k3: *mut nsIAtom; + pub static nsGkAtoms_k3: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2k4E"] - pub static nsGkAtoms_k4: *mut nsIAtom; + pub static nsGkAtoms_k4: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12kernelMatrixE"] - pub static nsGkAtoms_kernelMatrix: *mut nsIAtom; + pub static nsGkAtoms_kernelMatrix: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16kernelUnitLengthE"] - pub static nsGkAtoms_kernelUnitLength: *mut nsIAtom; + pub static nsGkAtoms_kernelUnitLength: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12lengthAdjustE"] - pub static nsGkAtoms_lengthAdjust: *mut nsIAtom; + pub static nsGkAtoms_lengthAdjust: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14letter_spacingE"] - pub static nsGkAtoms_letter_spacing: *mut nsIAtom; + pub static nsGkAtoms_letter_spacing: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7lightenE"] - pub static nsGkAtoms_lighten: *mut nsIAtom; + pub static nsGkAtoms_lighten: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14lighting_colorE"] - pub static nsGkAtoms_lighting_color: *mut nsIAtom; + pub static nsGkAtoms_lighting_color: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17limitingConeAngleE"] - pub static nsGkAtoms_limitingConeAngle: *mut nsIAtom; + pub static nsGkAtoms_limitingConeAngle: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6linearE"] - pub static nsGkAtoms_linear: *mut nsIAtom; + pub static nsGkAtoms_linear: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14linearGradientE"] - pub static nsGkAtoms_linearGradient: *mut nsIAtom; + pub static nsGkAtoms_linearGradient: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9linearRGBE"] - pub static nsGkAtoms_linearRGB: *mut nsIAtom; + pub static nsGkAtoms_linearRGB: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15list_style_typeE"] - pub static nsGkAtoms_list_style_type: *mut nsIAtom; + pub static nsGkAtoms_list_style_type: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16luminanceToAlphaE"] - pub static nsGkAtoms_luminanceToAlpha: *mut nsIAtom; + pub static nsGkAtoms_luminanceToAlpha: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10luminosityE"] - pub static nsGkAtoms_luminosity: *mut nsIAtom; + pub static nsGkAtoms_luminosity: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7magnifyE"] - pub static nsGkAtoms_magnify: *mut nsIAtom; + pub static nsGkAtoms_magnify: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6markerE"] - pub static nsGkAtoms_marker: *mut nsIAtom; + pub static nsGkAtoms_marker: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10marker_endE"] - pub static nsGkAtoms_marker_end: *mut nsIAtom; + pub static nsGkAtoms_marker_end: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10marker_midE"] - pub static nsGkAtoms_marker_mid: *mut nsIAtom; + pub static nsGkAtoms_marker_mid: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12marker_startE"] - pub static nsGkAtoms_marker_start: *mut nsIAtom; + pub static nsGkAtoms_marker_start: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12markerHeightE"] - pub static nsGkAtoms_markerHeight: *mut nsIAtom; + pub static nsGkAtoms_markerHeight: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11markerUnitsE"] - pub static nsGkAtoms_markerUnits: *mut nsIAtom; + pub static nsGkAtoms_markerUnits: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11markerWidthE"] - pub static nsGkAtoms_markerWidth: *mut nsIAtom; + pub static nsGkAtoms_markerWidth: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4maskE"] - pub static nsGkAtoms_mask: *mut nsIAtom; + pub static nsGkAtoms_mask: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16maskContentUnitsE"] - pub static nsGkAtoms_maskContentUnits: *mut nsIAtom; + pub static nsGkAtoms_maskContentUnits: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9mask_typeE"] - pub static nsGkAtoms_mask_type: *mut nsIAtom; + pub static nsGkAtoms_mask_type: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9maskUnitsE"] - pub static nsGkAtoms_maskUnits: *mut nsIAtom; + pub static nsGkAtoms_maskUnits: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6matrixE"] - pub static nsGkAtoms_matrix: *mut nsIAtom; + pub static nsGkAtoms_matrix: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8metadataE"] - pub static nsGkAtoms_metadata: *mut nsIAtom; + pub static nsGkAtoms_metadata: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12missingGlyphE"] - pub static nsGkAtoms_missingGlyph: *mut nsIAtom; + pub static nsGkAtoms_missingGlyph: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2mmE"] - pub static nsGkAtoms_mm: *mut nsIAtom; + pub static nsGkAtoms_mm: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5mpathE"] - pub static nsGkAtoms_mpath: *mut nsIAtom; + pub static nsGkAtoms_mpath: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8noStitchE"] - pub static nsGkAtoms_noStitch: *mut nsIAtom; + pub static nsGkAtoms_noStitch: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10numOctavesE"] - pub static nsGkAtoms_numOctaves: *mut nsIAtom; + pub static nsGkAtoms_numOctaves: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8multiplyE"] - pub static nsGkAtoms_multiply: *mut nsIAtom; + pub static nsGkAtoms_multiply: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17objectBoundingBoxE"] - pub static nsGkAtoms_objectBoundingBox: *mut nsIAtom; + pub static nsGkAtoms_objectBoundingBox: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6offsetE"] - pub static nsGkAtoms_offset: *mut nsIAtom; + pub static nsGkAtoms_offset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onSVGLoadE"] - pub static nsGkAtoms_onSVGLoad: *mut nsIAtom; + pub static nsGkAtoms_onSVGLoad: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11onSVGResizeE"] - pub static nsGkAtoms_onSVGResize: *mut nsIAtom; + pub static nsGkAtoms_onSVGResize: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11onSVGScrollE"] - pub static nsGkAtoms_onSVGScroll: *mut nsIAtom; + pub static nsGkAtoms_onSVGScroll: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11onSVGUnloadE"] - pub static nsGkAtoms_onSVGUnload: *mut nsIAtom; + pub static nsGkAtoms_onSVGUnload: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onSVGZoomE"] - pub static nsGkAtoms_onSVGZoom: *mut nsIAtom; + pub static nsGkAtoms_onSVGZoom: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6onzoomE"] - pub static nsGkAtoms_onzoom: *mut nsIAtom; + pub static nsGkAtoms_onzoom: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7opacityE"] - pub static nsGkAtoms_opacity: *mut nsIAtom; + pub static nsGkAtoms_opacity: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9_operatorE"] - pub static nsGkAtoms__operator: *mut nsIAtom; + pub static nsGkAtoms__operator: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3outE"] - pub static nsGkAtoms_out: *mut nsIAtom; + pub static nsGkAtoms_out: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4overE"] - pub static nsGkAtoms_over: *mut nsIAtom; + pub static nsGkAtoms_over: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms27overridePreserveAspectRatioE"] - pub static nsGkAtoms_overridePreserveAspectRatio: *mut nsIAtom; + pub static nsGkAtoms_overridePreserveAspectRatio: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3padE"] - pub static nsGkAtoms_pad: *mut nsIAtom; + pub static nsGkAtoms_pad: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4pathE"] - pub static nsGkAtoms_path: *mut nsIAtom; + pub static nsGkAtoms_path: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10pathLengthE"] - pub static nsGkAtoms_pathLength: *mut nsIAtom; + pub static nsGkAtoms_pathLength: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19patternContentUnitsE"] - pub static nsGkAtoms_patternContentUnits: *mut nsIAtom; + pub static nsGkAtoms_patternContentUnits: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16patternTransformE"] - pub static nsGkAtoms_patternTransform: *mut nsIAtom; + pub static nsGkAtoms_patternTransform: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12patternUnitsE"] - pub static nsGkAtoms_patternUnits: *mut nsIAtom; + pub static nsGkAtoms_patternUnits: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2pcE"] - pub static nsGkAtoms_pc: *mut nsIAtom; + pub static nsGkAtoms_pc: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14pointer_eventsE"] - pub static nsGkAtoms_pointer_events: *mut nsIAtom; + pub static nsGkAtoms_pointer_events: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6pointsE"] - pub static nsGkAtoms_points: *mut nsIAtom; + pub static nsGkAtoms_points: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9pointsAtXE"] - pub static nsGkAtoms_pointsAtX: *mut nsIAtom; + pub static nsGkAtoms_pointsAtX: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9pointsAtYE"] - pub static nsGkAtoms_pointsAtY: *mut nsIAtom; + pub static nsGkAtoms_pointsAtY: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9pointsAtZE"] - pub static nsGkAtoms_pointsAtZ: *mut nsIAtom; + pub static nsGkAtoms_pointsAtZ: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8polylineE"] - pub static nsGkAtoms_polyline: *mut nsIAtom; + pub static nsGkAtoms_polyline: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13preserveAlphaE"] - pub static nsGkAtoms_preserveAlpha: *mut nsIAtom; + pub static nsGkAtoms_preserveAlpha: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19preserveAspectRatioE"] - pub static nsGkAtoms_preserveAspectRatio: *mut nsIAtom; + pub static nsGkAtoms_preserveAspectRatio: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14primitiveUnitsE"] - pub static nsGkAtoms_primitiveUnits: *mut nsIAtom; + pub static nsGkAtoms_primitiveUnits: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2ptE"] - pub static nsGkAtoms_pt: *mut nsIAtom; + pub static nsGkAtoms_pt: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2pxE"] - pub static nsGkAtoms_px: *mut nsIAtom; + pub static nsGkAtoms_px: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms1RE"] - pub static nsGkAtoms_R: *mut nsIAtom; + pub static nsGkAtoms_R: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms1rE"] - pub static nsGkAtoms_r: *mut nsIAtom; + pub static nsGkAtoms_r: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3radE"] - pub static nsGkAtoms_rad: *mut nsIAtom; + pub static nsGkAtoms_rad: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14radialGradientE"] - pub static nsGkAtoms_radialGradient: *mut nsIAtom; + pub static nsGkAtoms_radialGradient: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6radiusE"] - pub static nsGkAtoms_radius: *mut nsIAtom; + pub static nsGkAtoms_radius: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7reflectE"] - pub static nsGkAtoms_reflect: *mut nsIAtom; + pub static nsGkAtoms_reflect: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4refXE"] - pub static nsGkAtoms_refX: *mut nsIAtom; + pub static nsGkAtoms_refX: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4refYE"] - pub static nsGkAtoms_refY: *mut nsIAtom; + pub static nsGkAtoms_refY: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18requiredExtensionsE"] - pub static nsGkAtoms_requiredExtensions: *mut nsIAtom; + pub static nsGkAtoms_requiredExtensions: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16requiredFeaturesE"] - pub static nsGkAtoms_requiredFeatures: *mut nsIAtom; + pub static nsGkAtoms_requiredFeatures: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6rotateE"] - pub static nsGkAtoms_rotate: *mut nsIAtom; + pub static nsGkAtoms_rotate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2rxE"] - pub static nsGkAtoms_rx: *mut nsIAtom; + pub static nsGkAtoms_rx: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2ryE"] - pub static nsGkAtoms_ry: *mut nsIAtom; + pub static nsGkAtoms_ry: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8saturateE"] - pub static nsGkAtoms_saturate: *mut nsIAtom; + pub static nsGkAtoms_saturate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10saturationE"] - pub static nsGkAtoms_saturation: *mut nsIAtom; + pub static nsGkAtoms_saturation: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3setE"] - pub static nsGkAtoms_set: *mut nsIAtom; + pub static nsGkAtoms_set: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4seedE"] - pub static nsGkAtoms_seed: *mut nsIAtom; + pub static nsGkAtoms_seed: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15shape_renderingE"] - pub static nsGkAtoms_shape_rendering: *mut nsIAtom; + pub static nsGkAtoms_shape_rendering: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5skewXE"] - pub static nsGkAtoms_skewX: *mut nsIAtom; + pub static nsGkAtoms_skewX: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5skewYE"] - pub static nsGkAtoms_skewY: *mut nsIAtom; + pub static nsGkAtoms_skewY: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5slopeE"] - pub static nsGkAtoms_slope: *mut nsIAtom; + pub static nsGkAtoms_slope: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4slotE"] - pub static nsGkAtoms_slot: *mut nsIAtom; + pub static nsGkAtoms_slot: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9softLightE"] - pub static nsGkAtoms_softLight: *mut nsIAtom; + pub static nsGkAtoms_softLight: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7spacingE"] - pub static nsGkAtoms_spacing: *mut nsIAtom; + pub static nsGkAtoms_spacing: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16spacingAndGlyphsE"] - pub static nsGkAtoms_spacingAndGlyphs: *mut nsIAtom; + pub static nsGkAtoms_spacingAndGlyphs: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16specularConstantE"] - pub static nsGkAtoms_specularConstant: *mut nsIAtom; + pub static nsGkAtoms_specularConstant: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16specularExponentE"] - pub static nsGkAtoms_specularExponent: *mut nsIAtom; + pub static nsGkAtoms_specularExponent: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12spreadMethodE"] - pub static nsGkAtoms_spreadMethod: *mut nsIAtom; + pub static nsGkAtoms_spreadMethod: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4sRGBE"] - pub static nsGkAtoms_sRGB: *mut nsIAtom; + pub static nsGkAtoms_sRGB: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11startOffsetE"] - pub static nsGkAtoms_startOffset: *mut nsIAtom; + pub static nsGkAtoms_startOffset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12stdDeviationE"] - pub static nsGkAtoms_stdDeviation: *mut nsIAtom; + pub static nsGkAtoms_stdDeviation: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6stitchE"] - pub static nsGkAtoms_stitch: *mut nsIAtom; + pub static nsGkAtoms_stitch: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11stitchTilesE"] - pub static nsGkAtoms_stitchTiles: *mut nsIAtom; + pub static nsGkAtoms_stitchTiles: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10stop_colorE"] - pub static nsGkAtoms_stop_color: *mut nsIAtom; + pub static nsGkAtoms_stop_color: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12stop_opacityE"] - pub static nsGkAtoms_stop_opacity: *mut nsIAtom; + pub static nsGkAtoms_stop_opacity: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6strokeE"] - pub static nsGkAtoms_stroke: *mut nsIAtom; + pub static nsGkAtoms_stroke: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16stroke_dasharrayE"] - pub static nsGkAtoms_stroke_dasharray: *mut nsIAtom; + pub static nsGkAtoms_stroke_dasharray: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17stroke_dashoffsetE"] - pub static nsGkAtoms_stroke_dashoffset: *mut nsIAtom; + pub static nsGkAtoms_stroke_dashoffset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14stroke_linecapE"] - pub static nsGkAtoms_stroke_linecap: *mut nsIAtom; + pub static nsGkAtoms_stroke_linecap: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15stroke_linejoinE"] - pub static nsGkAtoms_stroke_linejoin: *mut nsIAtom; + pub static nsGkAtoms_stroke_linejoin: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17stroke_miterlimitE"] - pub static nsGkAtoms_stroke_miterlimit: *mut nsIAtom; + pub static nsGkAtoms_stroke_miterlimit: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14stroke_opacityE"] - pub static nsGkAtoms_stroke_opacity: *mut nsIAtom; + pub static nsGkAtoms_stroke_opacity: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12stroke_widthE"] - pub static nsGkAtoms_stroke_width: *mut nsIAtom; + pub static nsGkAtoms_stroke_width: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11strokeWidthE"] - pub static nsGkAtoms_strokeWidth: *mut nsIAtom; + pub static nsGkAtoms_strokeWidth: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12surfaceScaleE"] - pub static nsGkAtoms_surfaceScale: *mut nsIAtom; + pub static nsGkAtoms_surfaceScale: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3svgE"] - pub static nsGkAtoms_svg: *mut nsIAtom; + pub static nsGkAtoms_svg: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15svgContextPaintE"] - pub static nsGkAtoms_svgContextPaint: *mut nsIAtom; + pub static nsGkAtoms_svgContextPaint: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9svgSwitchE"] - pub static nsGkAtoms_svgSwitch: *mut nsIAtom; + pub static nsGkAtoms_svgSwitch: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6symbolE"] - pub static nsGkAtoms_symbol: *mut nsIAtom; + pub static nsGkAtoms_symbol: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14systemLanguageE"] - pub static nsGkAtoms_systemLanguage: *mut nsIAtom; + pub static nsGkAtoms_systemLanguage: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11tableValuesE"] - pub static nsGkAtoms_tableValues: *mut nsIAtom; + pub static nsGkAtoms_tableValues: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7targetXE"] - pub static nsGkAtoms_targetX: *mut nsIAtom; + pub static nsGkAtoms_targetX: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7targetYE"] - pub static nsGkAtoms_targetY: *mut nsIAtom; + pub static nsGkAtoms_targetY: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11text_anchorE"] - pub static nsGkAtoms_text_anchor: *mut nsIAtom; + pub static nsGkAtoms_text_anchor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14text_renderingE"] - pub static nsGkAtoms_text_rendering: *mut nsIAtom; + pub static nsGkAtoms_text_rendering: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10textLengthE"] - pub static nsGkAtoms_textLength: *mut nsIAtom; + pub static nsGkAtoms_textLength: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8textPathE"] - pub static nsGkAtoms_textPath: *mut nsIAtom; + pub static nsGkAtoms_textPath: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4trefE"] - pub static nsGkAtoms_tref: *mut nsIAtom; + pub static nsGkAtoms_tref: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5tspanE"] - pub static nsGkAtoms_tspan: *mut nsIAtom; + pub static nsGkAtoms_tspan: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10turbulenceE"] - pub static nsGkAtoms_turbulence: *mut nsIAtom; + pub static nsGkAtoms_turbulence: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12unicode_bidiE"] - pub static nsGkAtoms_unicode_bidi: *mut nsIAtom; + pub static nsGkAtoms_unicode_bidi: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14userSpaceOnUseE"] - pub static nsGkAtoms_userSpaceOnUse: *mut nsIAtom; + pub static nsGkAtoms_userSpaceOnUse: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4viewE"] - pub static nsGkAtoms_view: *mut nsIAtom; + pub static nsGkAtoms_view: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7viewBoxE"] - pub static nsGkAtoms_viewBox: *mut nsIAtom; + pub static nsGkAtoms_viewBox: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10viewTargetE"] - pub static nsGkAtoms_viewTarget: *mut nsIAtom; + pub static nsGkAtoms_viewTarget: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11white_spaceE"] - pub static nsGkAtoms_white_space: *mut nsIAtom; + pub static nsGkAtoms_white_space: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12word_spacingE"] - pub static nsGkAtoms_word_spacing: *mut nsIAtom; + pub static nsGkAtoms_word_spacing: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12writing_modeE"] - pub static nsGkAtoms_writing_mode: *mut nsIAtom; + pub static nsGkAtoms_writing_mode: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms1xE"] - pub static nsGkAtoms_x: *mut nsIAtom; + pub static nsGkAtoms_x: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2x1E"] - pub static nsGkAtoms_x1: *mut nsIAtom; + pub static nsGkAtoms_x1: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2x2E"] - pub static nsGkAtoms_x2: *mut nsIAtom; + pub static nsGkAtoms_x2: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16xChannelSelectorE"] - pub static nsGkAtoms_xChannelSelector: *mut nsIAtom; + pub static nsGkAtoms_xChannelSelector: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4xor_E"] - pub static nsGkAtoms_xor_: *mut nsIAtom; + pub static nsGkAtoms_xor_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms1yE"] - pub static nsGkAtoms_y: *mut nsIAtom; + pub static nsGkAtoms_y: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2y1E"] - pub static nsGkAtoms_y1: *mut nsIAtom; + pub static nsGkAtoms_y1: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2y2E"] - pub static nsGkAtoms_y2: *mut nsIAtom; + pub static nsGkAtoms_y2: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16yChannelSelectorE"] - pub static nsGkAtoms_yChannelSelector: *mut nsIAtom; + pub static nsGkAtoms_yChannelSelector: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms1zE"] - pub static nsGkAtoms_z: *mut nsIAtom; + pub static nsGkAtoms_z: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10zoomAndPanE"] - pub static nsGkAtoms_zoomAndPan: *mut nsIAtom; + pub static nsGkAtoms_zoomAndPan: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13vector_effectE"] - pub static nsGkAtoms_vector_effect: *mut nsIAtom; + pub static nsGkAtoms_vector_effect: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14vertical_alignE"] - pub static nsGkAtoms_vertical_align: *mut nsIAtom; + pub static nsGkAtoms_vertical_align: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10accumulateE"] - pub static nsGkAtoms_accumulate: *mut nsIAtom; + pub static nsGkAtoms_accumulate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8additiveE"] - pub static nsGkAtoms_additive: *mut nsIAtom; + pub static nsGkAtoms_additive: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13attributeNameE"] - pub static nsGkAtoms_attributeName: *mut nsIAtom; + pub static nsGkAtoms_attributeName: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13attributeTypeE"] - pub static nsGkAtoms_attributeType: *mut nsIAtom; + pub static nsGkAtoms_attributeType: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12auto_reverseE"] - pub static nsGkAtoms_auto_reverse: *mut nsIAtom; + pub static nsGkAtoms_auto_reverse: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5beginE"] - pub static nsGkAtoms_begin: *mut nsIAtom; + pub static nsGkAtoms_begin: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10beginEventE"] - pub static nsGkAtoms_beginEvent: *mut nsIAtom; + pub static nsGkAtoms_beginEvent: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2byE"] - pub static nsGkAtoms_by: *mut nsIAtom; + pub static nsGkAtoms_by: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8calcModeE"] - pub static nsGkAtoms_calcMode: *mut nsIAtom; + pub static nsGkAtoms_calcMode: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3cssE"] - pub static nsGkAtoms_css: *mut nsIAtom; + pub static nsGkAtoms_css: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3durE"] - pub static nsGkAtoms_dur: *mut nsIAtom; + pub static nsGkAtoms_dur: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9keyPointsE"] - pub static nsGkAtoms_keyPoints: *mut nsIAtom; + pub static nsGkAtoms_keyPoints: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10keySplinesE"] - pub static nsGkAtoms_keySplines: *mut nsIAtom; + pub static nsGkAtoms_keySplines: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8keyTimesE"] - pub static nsGkAtoms_keyTimes: *mut nsIAtom; + pub static nsGkAtoms_keyTimes: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms25mozAnimateMotionDummyAttrE"] - pub static nsGkAtoms_mozAnimateMotionDummyAttr: *mut nsIAtom; + pub static nsGkAtoms_mozAnimateMotionDummyAttr: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7onbeginE"] - pub static nsGkAtoms_onbegin: *mut nsIAtom; + pub static nsGkAtoms_onbegin: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onbeginEventE"] - pub static nsGkAtoms_onbeginEvent: *mut nsIAtom; + pub static nsGkAtoms_onbeginEvent: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5onendE"] - pub static nsGkAtoms_onend: *mut nsIAtom; + pub static nsGkAtoms_onend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onendEventE"] - pub static nsGkAtoms_onendEvent: *mut nsIAtom; + pub static nsGkAtoms_onendEvent: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8onrepeatE"] - pub static nsGkAtoms_onrepeat: *mut nsIAtom; + pub static nsGkAtoms_onrepeat: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onrepeatEventE"] - pub static nsGkAtoms_onrepeatEvent: *mut nsIAtom; + pub static nsGkAtoms_onrepeatEvent: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11repeatCountE"] - pub static nsGkAtoms_repeatCount: *mut nsIAtom; + pub static nsGkAtoms_repeatCount: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9repeatDurE"] - pub static nsGkAtoms_repeatDur: *mut nsIAtom; + pub static nsGkAtoms_repeatDur: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11repeatEventE"] - pub static nsGkAtoms_repeatEvent: *mut nsIAtom; + pub static nsGkAtoms_repeatEvent: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7restartE"] - pub static nsGkAtoms_restart: *mut nsIAtom; + pub static nsGkAtoms_restart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2toE"] - pub static nsGkAtoms_to: *mut nsIAtom; + pub static nsGkAtoms_to: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3XMLE"] - pub static nsGkAtoms_XML: *mut nsIAtom; + pub static nsGkAtoms_XML: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4abs_E"] - pub static nsGkAtoms_abs_: *mut nsIAtom; + pub static nsGkAtoms_abs_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7accent_E"] - pub static nsGkAtoms_accent_: *mut nsIAtom; + pub static nsGkAtoms_accent_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12accentunder_E"] - pub static nsGkAtoms_accentunder_: *mut nsIAtom; + pub static nsGkAtoms_accentunder_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11actiontype_E"] - pub static nsGkAtoms_actiontype_: *mut nsIAtom; + pub static nsGkAtoms_actiontype_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15alignmentscope_E"] - pub static nsGkAtoms_alignmentscope_: *mut nsIAtom; + pub static nsGkAtoms_alignmentscope_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7altimg_E"] - pub static nsGkAtoms_altimg_: *mut nsIAtom; + pub static nsGkAtoms_altimg_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14altimg_height_E"] - pub static nsGkAtoms_altimg_height_: *mut nsIAtom; + pub static nsGkAtoms_altimg_height_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14altimg_valign_E"] - pub static nsGkAtoms_altimg_valign_: *mut nsIAtom; + pub static nsGkAtoms_altimg_valign_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13altimg_width_E"] - pub static nsGkAtoms_altimg_width_: *mut nsIAtom; + pub static nsGkAtoms_altimg_width_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11annotation_E"] - pub static nsGkAtoms_annotation_: *mut nsIAtom; + pub static nsGkAtoms_annotation_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15annotation_xml_E"] - pub static nsGkAtoms_annotation_xml_: *mut nsIAtom; + pub static nsGkAtoms_annotation_xml_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6apply_E"] - pub static nsGkAtoms_apply_: *mut nsIAtom; + pub static nsGkAtoms_apply_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7approx_E"] - pub static nsGkAtoms_approx_: *mut nsIAtom; + pub static nsGkAtoms_approx_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7arccos_E"] - pub static nsGkAtoms_arccos_: *mut nsIAtom; + pub static nsGkAtoms_arccos_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8arccosh_E"] - pub static nsGkAtoms_arccosh_: *mut nsIAtom; + pub static nsGkAtoms_arccosh_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7arccot_E"] - pub static nsGkAtoms_arccot_: *mut nsIAtom; + pub static nsGkAtoms_arccot_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8arccoth_E"] - pub static nsGkAtoms_arccoth_: *mut nsIAtom; + pub static nsGkAtoms_arccoth_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7arccsc_E"] - pub static nsGkAtoms_arccsc_: *mut nsIAtom; + pub static nsGkAtoms_arccsc_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8arccsch_E"] - pub static nsGkAtoms_arccsch_: *mut nsIAtom; + pub static nsGkAtoms_arccsch_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7arcsec_E"] - pub static nsGkAtoms_arcsec_: *mut nsIAtom; + pub static nsGkAtoms_arcsec_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8arcsech_E"] - pub static nsGkAtoms_arcsech_: *mut nsIAtom; + pub static nsGkAtoms_arcsech_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7arcsin_E"] - pub static nsGkAtoms_arcsin_: *mut nsIAtom; + pub static nsGkAtoms_arcsin_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8arcsinh_E"] - pub static nsGkAtoms_arcsinh_: *mut nsIAtom; + pub static nsGkAtoms_arcsinh_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7arctan_E"] - pub static nsGkAtoms_arctan_: *mut nsIAtom; + pub static nsGkAtoms_arctan_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8arctanh_E"] - pub static nsGkAtoms_arctanh_: *mut nsIAtom; + pub static nsGkAtoms_arctanh_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4arg_E"] - pub static nsGkAtoms_arg_: *mut nsIAtom; + pub static nsGkAtoms_arg_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9bevelled_E"] - pub static nsGkAtoms_bevelled_: *mut nsIAtom; + pub static nsGkAtoms_bevelled_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5bind_E"] - pub static nsGkAtoms_bind_: *mut nsIAtom; + pub static nsGkAtoms_bind_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5bvar_E"] - pub static nsGkAtoms_bvar_: *mut nsIAtom; + pub static nsGkAtoms_bvar_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5card_E"] - pub static nsGkAtoms_card_: *mut nsIAtom; + pub static nsGkAtoms_card_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17cartesianproduct_E"] - pub static nsGkAtoms_cartesianproduct_: *mut nsIAtom; + pub static nsGkAtoms_cartesianproduct_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7cbytes_E"] - pub static nsGkAtoms_cbytes_: *mut nsIAtom; + pub static nsGkAtoms_cbytes_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3cd_E"] - pub static nsGkAtoms_cd_: *mut nsIAtom; + pub static nsGkAtoms_cd_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8cdgroup_E"] - pub static nsGkAtoms_cdgroup_: *mut nsIAtom; + pub static nsGkAtoms_cdgroup_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7cerror_E"] - pub static nsGkAtoms_cerror_: *mut nsIAtom; + pub static nsGkAtoms_cerror_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10charalign_E"] - pub static nsGkAtoms_charalign_: *mut nsIAtom; + pub static nsGkAtoms_charalign_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3ci_E"] - pub static nsGkAtoms_ci_: *mut nsIAtom; + pub static nsGkAtoms_ci_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8closure_E"] - pub static nsGkAtoms_closure_: *mut nsIAtom; + pub static nsGkAtoms_closure_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3cn_E"] - pub static nsGkAtoms_cn_: *mut nsIAtom; + pub static nsGkAtoms_cn_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9codomain_E"] - pub static nsGkAtoms_codomain_: *mut nsIAtom; + pub static nsGkAtoms_codomain_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12columnalign_E"] - pub static nsGkAtoms_columnalign_: *mut nsIAtom; + pub static nsGkAtoms_columnalign_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16columnalignment_E"] - pub static nsGkAtoms_columnalignment_: *mut nsIAtom; + pub static nsGkAtoms_columnalignment_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12columnlines_E"] - pub static nsGkAtoms_columnlines_: *mut nsIAtom; + pub static nsGkAtoms_columnlines_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14columnspacing_E"] - pub static nsGkAtoms_columnspacing_: *mut nsIAtom; + pub static nsGkAtoms_columnspacing_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11columnspan_E"] - pub static nsGkAtoms_columnspan_: *mut nsIAtom; + pub static nsGkAtoms_columnspan_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12columnwidth_E"] - pub static nsGkAtoms_columnwidth_: *mut nsIAtom; + pub static nsGkAtoms_columnwidth_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10complexes_E"] - pub static nsGkAtoms_complexes_: *mut nsIAtom; + pub static nsGkAtoms_complexes_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8compose_E"] - pub static nsGkAtoms_compose_: *mut nsIAtom; + pub static nsGkAtoms_compose_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10condition_E"] - pub static nsGkAtoms_condition_: *mut nsIAtom; + pub static nsGkAtoms_condition_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10conjugate_E"] - pub static nsGkAtoms_conjugate_: *mut nsIAtom; + pub static nsGkAtoms_conjugate_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4cos_E"] - pub static nsGkAtoms_cos_: *mut nsIAtom; + pub static nsGkAtoms_cos_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5cosh_E"] - pub static nsGkAtoms_cosh_: *mut nsIAtom; + pub static nsGkAtoms_cosh_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4cot_E"] - pub static nsGkAtoms_cot_: *mut nsIAtom; + pub static nsGkAtoms_cot_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5coth_E"] - pub static nsGkAtoms_coth_: *mut nsIAtom; + pub static nsGkAtoms_coth_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9crossout_E"] - pub static nsGkAtoms_crossout_: *mut nsIAtom; + pub static nsGkAtoms_crossout_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4csc_E"] - pub static nsGkAtoms_csc_: *mut nsIAtom; + pub static nsGkAtoms_csc_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5csch_E"] - pub static nsGkAtoms_csch_: *mut nsIAtom; + pub static nsGkAtoms_csch_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3cs_E"] - pub static nsGkAtoms_cs_: *mut nsIAtom; + pub static nsGkAtoms_cs_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8csymbol_E"] - pub static nsGkAtoms_csymbol_: *mut nsIAtom; + pub static nsGkAtoms_csymbol_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5curl_E"] - pub static nsGkAtoms_curl_: *mut nsIAtom; + pub static nsGkAtoms_curl_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13decimalpoint_E"] - pub static nsGkAtoms_decimalpoint_: *mut nsIAtom; + pub static nsGkAtoms_decimalpoint_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14definitionURL_E"] - pub static nsGkAtoms_definitionURL_: *mut nsIAtom; + pub static nsGkAtoms_definitionURL_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7degree_E"] - pub static nsGkAtoms_degree_: *mut nsIAtom; + pub static nsGkAtoms_degree_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11denomalign_E"] - pub static nsGkAtoms_denomalign_: *mut nsIAtom; + pub static nsGkAtoms_denomalign_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6depth_E"] - pub static nsGkAtoms_depth_: *mut nsIAtom; + pub static nsGkAtoms_depth_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12determinant_E"] - pub static nsGkAtoms_determinant_: *mut nsIAtom; + pub static nsGkAtoms_determinant_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5diff_E"] - pub static nsGkAtoms_diff_: *mut nsIAtom; + pub static nsGkAtoms_diff_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13displaystyle_E"] - pub static nsGkAtoms_displaystyle_: *mut nsIAtom; + pub static nsGkAtoms_displaystyle_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11divergence_E"] - pub static nsGkAtoms_divergence_: *mut nsIAtom; + pub static nsGkAtoms_divergence_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7divide_E"] - pub static nsGkAtoms_divide_: *mut nsIAtom; + pub static nsGkAtoms_divide_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7domain_E"] - pub static nsGkAtoms_domain_: *mut nsIAtom; + pub static nsGkAtoms_domain_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20domainofapplication_E"] - pub static nsGkAtoms_domainofapplication_: *mut nsIAtom; + pub static nsGkAtoms_domainofapplication_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5edge_E"] - pub static nsGkAtoms_edge_: *mut nsIAtom; + pub static nsGkAtoms_edge_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3el_E"] - pub static nsGkAtoms_el_: *mut nsIAtom; + pub static nsGkAtoms_el_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9emptyset_E"] - pub static nsGkAtoms_emptyset_: *mut nsIAtom; + pub static nsGkAtoms_emptyset_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3eq_E"] - pub static nsGkAtoms_eq_: *mut nsIAtom; + pub static nsGkAtoms_eq_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13equalcolumns_E"] - pub static nsGkAtoms_equalcolumns_: *mut nsIAtom; + pub static nsGkAtoms_equalcolumns_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10equalrows_E"] - pub static nsGkAtoms_equalrows_: *mut nsIAtom; + pub static nsGkAtoms_equalrows_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11equivalent_E"] - pub static nsGkAtoms_equivalent_: *mut nsIAtom; + pub static nsGkAtoms_equivalent_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11eulergamma_E"] - pub static nsGkAtoms_eulergamma_: *mut nsIAtom; + pub static nsGkAtoms_eulergamma_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7exists_E"] - pub static nsGkAtoms_exists_: *mut nsIAtom; + pub static nsGkAtoms_exists_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4exp_E"] - pub static nsGkAtoms_exp_: *mut nsIAtom; + pub static nsGkAtoms_exp_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13exponentiale_E"] - pub static nsGkAtoms_exponentiale_: *mut nsIAtom; + pub static nsGkAtoms_exponentiale_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10factorial_E"] - pub static nsGkAtoms_factorial_: *mut nsIAtom; + pub static nsGkAtoms_factorial_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9factorof_E"] - pub static nsGkAtoms_factorof_: *mut nsIAtom; + pub static nsGkAtoms_factorof_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6fence_E"] - pub static nsGkAtoms_fence_: *mut nsIAtom; + pub static nsGkAtoms_fence_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3fn_E"] - pub static nsGkAtoms_fn_: *mut nsIAtom; + pub static nsGkAtoms_fn_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11fontfamily_E"] - pub static nsGkAtoms_fontfamily_: *mut nsIAtom; + pub static nsGkAtoms_fontfamily_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9fontsize_E"] - pub static nsGkAtoms_fontsize_: *mut nsIAtom; + pub static nsGkAtoms_fontsize_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10fontstyle_E"] - pub static nsGkAtoms_fontstyle_: *mut nsIAtom; + pub static nsGkAtoms_fontstyle_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11fontweight_E"] - pub static nsGkAtoms_fontweight_: *mut nsIAtom; + pub static nsGkAtoms_fontweight_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7forall_E"] - pub static nsGkAtoms_forall_: *mut nsIAtom; + pub static nsGkAtoms_forall_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13framespacing_E"] - pub static nsGkAtoms_framespacing_: *mut nsIAtom; + pub static nsGkAtoms_framespacing_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4gcd_E"] - pub static nsGkAtoms_gcd_: *mut nsIAtom; + pub static nsGkAtoms_gcd_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4geq_E"] - pub static nsGkAtoms_geq_: *mut nsIAtom; + pub static nsGkAtoms_geq_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11groupalign_E"] - pub static nsGkAtoms_groupalign_: *mut nsIAtom; + pub static nsGkAtoms_groupalign_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3gt_E"] - pub static nsGkAtoms_gt_: *mut nsIAtom; + pub static nsGkAtoms_gt_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6ident_E"] - pub static nsGkAtoms_ident_: *mut nsIAtom; + pub static nsGkAtoms_ident_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11imaginaryi_E"] - pub static nsGkAtoms_imaginaryi_: *mut nsIAtom; + pub static nsGkAtoms_imaginaryi_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10imaginary_E"] - pub static nsGkAtoms_imaginary_: *mut nsIAtom; + pub static nsGkAtoms_imaginary_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8implies_E"] - pub static nsGkAtoms_implies_: *mut nsIAtom; + pub static nsGkAtoms_implies_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17indentalignfirst_E"] - pub static nsGkAtoms_indentalignfirst_: *mut nsIAtom; + pub static nsGkAtoms_indentalignfirst_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12indentalign_E"] - pub static nsGkAtoms_indentalign_: *mut nsIAtom; + pub static nsGkAtoms_indentalign_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16indentalignlast_E"] - pub static nsGkAtoms_indentalignlast_: *mut nsIAtom; + pub static nsGkAtoms_indentalignlast_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17indentshiftfirst_E"] - pub static nsGkAtoms_indentshiftfirst_: *mut nsIAtom; + pub static nsGkAtoms_indentshiftfirst_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12indentshift_E"] - pub static nsGkAtoms_indentshift_: *mut nsIAtom; + pub static nsGkAtoms_indentshift_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13indenttarget_E"] - pub static nsGkAtoms_indenttarget_: *mut nsIAtom; + pub static nsGkAtoms_indenttarget_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9integers_E"] - pub static nsGkAtoms_integers_: *mut nsIAtom; + pub static nsGkAtoms_integers_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10intersect_E"] - pub static nsGkAtoms_intersect_: *mut nsIAtom; + pub static nsGkAtoms_intersect_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9interval_E"] - pub static nsGkAtoms_interval_: *mut nsIAtom; + pub static nsGkAtoms_interval_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4int_E"] - pub static nsGkAtoms_int_: *mut nsIAtom; + pub static nsGkAtoms_int_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8inverse_E"] - pub static nsGkAtoms_inverse_: *mut nsIAtom; + pub static nsGkAtoms_inverse_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7lambda_E"] - pub static nsGkAtoms_lambda_: *mut nsIAtom; + pub static nsGkAtoms_lambda_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10laplacian_E"] - pub static nsGkAtoms_laplacian_: *mut nsIAtom; + pub static nsGkAtoms_laplacian_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8largeop_E"] - pub static nsGkAtoms_largeop_: *mut nsIAtom; + pub static nsGkAtoms_largeop_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4lcm_E"] - pub static nsGkAtoms_lcm_: *mut nsIAtom; + pub static nsGkAtoms_lcm_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4leq_E"] - pub static nsGkAtoms_leq_: *mut nsIAtom; + pub static nsGkAtoms_leq_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6limit_E"] - pub static nsGkAtoms_limit_: *mut nsIAtom; + pub static nsGkAtoms_limit_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10linebreak_E"] - pub static nsGkAtoms_linebreak_: *mut nsIAtom; + pub static nsGkAtoms_linebreak_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18linebreakmultchar_E"] - pub static nsGkAtoms_linebreakmultchar_: *mut nsIAtom; + pub static nsGkAtoms_linebreakmultchar_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15linebreakstyle_E"] - pub static nsGkAtoms_linebreakstyle_: *mut nsIAtom; + pub static nsGkAtoms_linebreakstyle_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14linethickness_E"] - pub static nsGkAtoms_linethickness_: *mut nsIAtom; + pub static nsGkAtoms_linethickness_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5list_E"] - pub static nsGkAtoms_list_: *mut nsIAtom; + pub static nsGkAtoms_list_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3ln_E"] - pub static nsGkAtoms_ln_: *mut nsIAtom; + pub static nsGkAtoms_ln_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9location_E"] - pub static nsGkAtoms_location_: *mut nsIAtom; + pub static nsGkAtoms_location_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8logbase_E"] - pub static nsGkAtoms_logbase_: *mut nsIAtom; + pub static nsGkAtoms_logbase_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4log_E"] - pub static nsGkAtoms_log_: *mut nsIAtom; + pub static nsGkAtoms_log_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13longdivstyle_E"] - pub static nsGkAtoms_longdivstyle_: *mut nsIAtom; + pub static nsGkAtoms_longdivstyle_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9lowlimit_E"] - pub static nsGkAtoms_lowlimit_: *mut nsIAtom; + pub static nsGkAtoms_lowlimit_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7lquote_E"] - pub static nsGkAtoms_lquote_: *mut nsIAtom; + pub static nsGkAtoms_lquote_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7lspace_E"] - pub static nsGkAtoms_lspace_: *mut nsIAtom; + pub static nsGkAtoms_lspace_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3lt_E"] - pub static nsGkAtoms_lt_: *mut nsIAtom; + pub static nsGkAtoms_lt_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8maction_E"] - pub static nsGkAtoms_maction_: *mut nsIAtom; + pub static nsGkAtoms_maction_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12maligngroup_E"] - pub static nsGkAtoms_maligngroup_: *mut nsIAtom; + pub static nsGkAtoms_maligngroup_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11malignmark_E"] - pub static nsGkAtoms_malignmark_: *mut nsIAtom; + pub static nsGkAtoms_malignmark_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15mathbackground_E"] - pub static nsGkAtoms_mathbackground_: *mut nsIAtom; + pub static nsGkAtoms_mathbackground_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10mathcolor_E"] - pub static nsGkAtoms_mathcolor_: *mut nsIAtom; + pub static nsGkAtoms_mathcolor_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9mathsize_E"] - pub static nsGkAtoms_mathsize_: *mut nsIAtom; + pub static nsGkAtoms_mathsize_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12mathvariant_E"] - pub static nsGkAtoms_mathvariant_: *mut nsIAtom; + pub static nsGkAtoms_mathvariant_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10matrixrow_E"] - pub static nsGkAtoms_matrixrow_: *mut nsIAtom; + pub static nsGkAtoms_matrixrow_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8maxsize_E"] - pub static nsGkAtoms_maxsize_: *mut nsIAtom; + pub static nsGkAtoms_maxsize_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5mean_E"] - pub static nsGkAtoms_mean_: *mut nsIAtom; + pub static nsGkAtoms_mean_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7median_E"] - pub static nsGkAtoms_median_: *mut nsIAtom; + pub static nsGkAtoms_median_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9menclose_E"] - pub static nsGkAtoms_menclose_: *mut nsIAtom; + pub static nsGkAtoms_menclose_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7merror_E"] - pub static nsGkAtoms_merror_: *mut nsIAtom; + pub static nsGkAtoms_merror_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8mfenced_E"] - pub static nsGkAtoms_mfenced_: *mut nsIAtom; + pub static nsGkAtoms_mfenced_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6mfrac_E"] - pub static nsGkAtoms_mfrac_: *mut nsIAtom; + pub static nsGkAtoms_mfrac_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7mglyph_E"] - pub static nsGkAtoms_mglyph_: *mut nsIAtom; + pub static nsGkAtoms_mglyph_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3mi_E"] - pub static nsGkAtoms_mi_: *mut nsIAtom; + pub static nsGkAtoms_mi_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16minlabelspacing_E"] - pub static nsGkAtoms_minlabelspacing_: *mut nsIAtom; + pub static nsGkAtoms_minlabelspacing_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8minsize_E"] - pub static nsGkAtoms_minsize_: *mut nsIAtom; + pub static nsGkAtoms_minsize_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6minus_E"] - pub static nsGkAtoms_minus_: *mut nsIAtom; + pub static nsGkAtoms_minus_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11mlabeledtr_E"] - pub static nsGkAtoms_mlabeledtr_: *mut nsIAtom; + pub static nsGkAtoms_mlabeledtr_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9mlongdiv_E"] - pub static nsGkAtoms_mlongdiv_: *mut nsIAtom; + pub static nsGkAtoms_mlongdiv_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14mmultiscripts_E"] - pub static nsGkAtoms_mmultiscripts_: *mut nsIAtom; + pub static nsGkAtoms_mmultiscripts_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3mn_E"] - pub static nsGkAtoms_mn_: *mut nsIAtom; + pub static nsGkAtoms_mn_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12momentabout_E"] - pub static nsGkAtoms_momentabout_: *mut nsIAtom; + pub static nsGkAtoms_momentabout_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7moment_E"] - pub static nsGkAtoms_moment_: *mut nsIAtom; + pub static nsGkAtoms_moment_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3mo_E"] - pub static nsGkAtoms_mo_: *mut nsIAtom; + pub static nsGkAtoms_mo_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14movablelimits_E"] - pub static nsGkAtoms_movablelimits_: *mut nsIAtom; + pub static nsGkAtoms_movablelimits_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6mover_E"] - pub static nsGkAtoms_mover_: *mut nsIAtom; + pub static nsGkAtoms_mover_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8mpadded_E"] - pub static nsGkAtoms_mpadded_: *mut nsIAtom; + pub static nsGkAtoms_mpadded_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9mphantom_E"] - pub static nsGkAtoms_mphantom_: *mut nsIAtom; + pub static nsGkAtoms_mphantom_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12mprescripts_E"] - pub static nsGkAtoms_mprescripts_: *mut nsIAtom; + pub static nsGkAtoms_mprescripts_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6mroot_E"] - pub static nsGkAtoms_mroot_: *mut nsIAtom; + pub static nsGkAtoms_mroot_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5mrow_E"] - pub static nsGkAtoms_mrow_: *mut nsIAtom; + pub static nsGkAtoms_mrow_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10mscarries_E"] - pub static nsGkAtoms_mscarries_: *mut nsIAtom; + pub static nsGkAtoms_mscarries_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8mscarry_E"] - pub static nsGkAtoms_mscarry_: *mut nsIAtom; + pub static nsGkAtoms_mscarry_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8msgroup_E"] - pub static nsGkAtoms_msgroup_: *mut nsIAtom; + pub static nsGkAtoms_msgroup_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7msline_E"] - pub static nsGkAtoms_msline_: *mut nsIAtom; + pub static nsGkAtoms_msline_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3ms_E"] - pub static nsGkAtoms_ms_: *mut nsIAtom; + pub static nsGkAtoms_ms_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7mspace_E"] - pub static nsGkAtoms_mspace_: *mut nsIAtom; + pub static nsGkAtoms_mspace_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6msqrt_E"] - pub static nsGkAtoms_msqrt_: *mut nsIAtom; + pub static nsGkAtoms_msqrt_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6msrow_E"] - pub static nsGkAtoms_msrow_: *mut nsIAtom; + pub static nsGkAtoms_msrow_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7mstack_E"] - pub static nsGkAtoms_mstack_: *mut nsIAtom; + pub static nsGkAtoms_mstack_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7mstyle_E"] - pub static nsGkAtoms_mstyle_: *mut nsIAtom; + pub static nsGkAtoms_mstyle_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5msub_E"] - pub static nsGkAtoms_msub_: *mut nsIAtom; + pub static nsGkAtoms_msub_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8msubsup_E"] - pub static nsGkAtoms_msubsup_: *mut nsIAtom; + pub static nsGkAtoms_msubsup_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5msup_E"] - pub static nsGkAtoms_msup_: *mut nsIAtom; + pub static nsGkAtoms_msup_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7mtable_E"] - pub static nsGkAtoms_mtable_: *mut nsIAtom; + pub static nsGkAtoms_mtable_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4mtd_E"] - pub static nsGkAtoms_mtd_: *mut nsIAtom; + pub static nsGkAtoms_mtd_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6mtext_E"] - pub static nsGkAtoms_mtext_: *mut nsIAtom; + pub static nsGkAtoms_mtext_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4mtr_E"] - pub static nsGkAtoms_mtr_: *mut nsIAtom; + pub static nsGkAtoms_mtr_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7munder_E"] - pub static nsGkAtoms_munder_: *mut nsIAtom; + pub static nsGkAtoms_munder_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11munderover_E"] - pub static nsGkAtoms_munderover_: *mut nsIAtom; + pub static nsGkAtoms_munderover_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15naturalnumbers_E"] - pub static nsGkAtoms_naturalnumbers_: *mut nsIAtom; + pub static nsGkAtoms_naturalnumbers_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4neq_E"] - pub static nsGkAtoms_neq_: *mut nsIAtom; + pub static nsGkAtoms_neq_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11notanumber_E"] - pub static nsGkAtoms_notanumber_: *mut nsIAtom; + pub static nsGkAtoms_notanumber_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9notation_E"] - pub static nsGkAtoms_notation_: *mut nsIAtom; + pub static nsGkAtoms_notation_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5note_E"] - pub static nsGkAtoms_note_: *mut nsIAtom; + pub static nsGkAtoms_note_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6notin_E"] - pub static nsGkAtoms_notin_: *mut nsIAtom; + pub static nsGkAtoms_notin_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12notprsubset_E"] - pub static nsGkAtoms_notprsubset_: *mut nsIAtom; + pub static nsGkAtoms_notprsubset_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10notsubset_E"] - pub static nsGkAtoms_notsubset_: *mut nsIAtom; + pub static nsGkAtoms_notsubset_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9numalign_E"] - pub static nsGkAtoms_numalign_: *mut nsIAtom; + pub static nsGkAtoms_numalign_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6other_E"] - pub static nsGkAtoms_other_: *mut nsIAtom; + pub static nsGkAtoms_other_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13outerproduct_E"] - pub static nsGkAtoms_outerproduct_: *mut nsIAtom; + pub static nsGkAtoms_outerproduct_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12partialdiff_E"] - pub static nsGkAtoms_partialdiff_: *mut nsIAtom; + pub static nsGkAtoms_partialdiff_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6piece_E"] - pub static nsGkAtoms_piece_: *mut nsIAtom; + pub static nsGkAtoms_piece_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10piecewise_E"] - pub static nsGkAtoms_piecewise_: *mut nsIAtom; + pub static nsGkAtoms_piecewise_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3pi_E"] - pub static nsGkAtoms_pi_: *mut nsIAtom; + pub static nsGkAtoms_pi_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5plus_E"] - pub static nsGkAtoms_plus_: *mut nsIAtom; + pub static nsGkAtoms_plus_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6power_E"] - pub static nsGkAtoms_power_: *mut nsIAtom; + pub static nsGkAtoms_power_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7primes_E"] - pub static nsGkAtoms_primes_: *mut nsIAtom; + pub static nsGkAtoms_primes_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8product_E"] - pub static nsGkAtoms_product_: *mut nsIAtom; + pub static nsGkAtoms_product_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9prsubset_E"] - pub static nsGkAtoms_prsubset_: *mut nsIAtom; + pub static nsGkAtoms_prsubset_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9quotient_E"] - pub static nsGkAtoms_quotient_: *mut nsIAtom; + pub static nsGkAtoms_quotient_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10rationals_E"] - pub static nsGkAtoms_rationals_: *mut nsIAtom; + pub static nsGkAtoms_rationals_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5real_E"] - pub static nsGkAtoms_real_: *mut nsIAtom; + pub static nsGkAtoms_real_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6reals_E"] - pub static nsGkAtoms_reals_: *mut nsIAtom; + pub static nsGkAtoms_reals_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5reln_E"] - pub static nsGkAtoms_reln_: *mut nsIAtom; + pub static nsGkAtoms_reln_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5root_E"] - pub static nsGkAtoms_root_: *mut nsIAtom; + pub static nsGkAtoms_root_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9rowalign_E"] - pub static nsGkAtoms_rowalign_: *mut nsIAtom; + pub static nsGkAtoms_rowalign_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9rowlines_E"] - pub static nsGkAtoms_rowlines_: *mut nsIAtom; + pub static nsGkAtoms_rowlines_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11rowspacing_E"] - pub static nsGkAtoms_rowspacing_: *mut nsIAtom; + pub static nsGkAtoms_rowspacing_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7rquote_E"] - pub static nsGkAtoms_rquote_: *mut nsIAtom; + pub static nsGkAtoms_rquote_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7rspace_E"] - pub static nsGkAtoms_rspace_: *mut nsIAtom; + pub static nsGkAtoms_rspace_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14scalarproduct_E"] - pub static nsGkAtoms_scalarproduct_: *mut nsIAtom; + pub static nsGkAtoms_scalarproduct_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15schemaLocation_E"] - pub static nsGkAtoms_schemaLocation_: *mut nsIAtom; + pub static nsGkAtoms_schemaLocation_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12scriptlevel_E"] - pub static nsGkAtoms_scriptlevel_: *mut nsIAtom; + pub static nsGkAtoms_scriptlevel_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14scriptminsize_E"] - pub static nsGkAtoms_scriptminsize_: *mut nsIAtom; + pub static nsGkAtoms_scriptminsize_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21scriptsizemultiplier_E"] - pub static nsGkAtoms_scriptsizemultiplier_: *mut nsIAtom; + pub static nsGkAtoms_scriptsizemultiplier_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11scriptsize_E"] - pub static nsGkAtoms_scriptsize_: *mut nsIAtom; + pub static nsGkAtoms_scriptsize_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5sdev_E"] - pub static nsGkAtoms_sdev_: *mut nsIAtom; + pub static nsGkAtoms_sdev_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5sech_E"] - pub static nsGkAtoms_sech_: *mut nsIAtom; + pub static nsGkAtoms_sech_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4sec_E"] - pub static nsGkAtoms_sec_: *mut nsIAtom; + pub static nsGkAtoms_sec_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10selection_E"] - pub static nsGkAtoms_selection_: *mut nsIAtom; + pub static nsGkAtoms_selection_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9selector_E"] - pub static nsGkAtoms_selector_: *mut nsIAtom; + pub static nsGkAtoms_selector_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10semantics_E"] - pub static nsGkAtoms_semantics_: *mut nsIAtom; + pub static nsGkAtoms_semantics_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10separator_E"] - pub static nsGkAtoms_separator_: *mut nsIAtom; + pub static nsGkAtoms_separator_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11separators_E"] - pub static nsGkAtoms_separators_: *mut nsIAtom; + pub static nsGkAtoms_separators_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4sep_E"] - pub static nsGkAtoms_sep_: *mut nsIAtom; + pub static nsGkAtoms_sep_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8setdiff_E"] - pub static nsGkAtoms_setdiff_: *mut nsIAtom; + pub static nsGkAtoms_setdiff_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4set_E"] - pub static nsGkAtoms_set_: *mut nsIAtom; + pub static nsGkAtoms_set_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6share_E"] - pub static nsGkAtoms_share_: *mut nsIAtom; + pub static nsGkAtoms_share_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6shift_E"] - pub static nsGkAtoms_shift_: *mut nsIAtom; + pub static nsGkAtoms_shift_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5side_E"] - pub static nsGkAtoms_side_: *mut nsIAtom; + pub static nsGkAtoms_side_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5sinh_E"] - pub static nsGkAtoms_sinh_: *mut nsIAtom; + pub static nsGkAtoms_sinh_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4sin_E"] - pub static nsGkAtoms_sin_: *mut nsIAtom; + pub static nsGkAtoms_sin_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11stackalign_E"] - pub static nsGkAtoms_stackalign_: *mut nsIAtom; + pub static nsGkAtoms_stackalign_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9stretchy_E"] - pub static nsGkAtoms_stretchy_: *mut nsIAtom; + pub static nsGkAtoms_stretchy_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15subscriptshift_E"] - pub static nsGkAtoms_subscriptshift_: *mut nsIAtom; + pub static nsGkAtoms_subscriptshift_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7subset_E"] - pub static nsGkAtoms_subset_: *mut nsIAtom; + pub static nsGkAtoms_subset_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17superscriptshift_E"] - pub static nsGkAtoms_superscriptshift_: *mut nsIAtom; + pub static nsGkAtoms_superscriptshift_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10symmetric_E"] - pub static nsGkAtoms_symmetric_: *mut nsIAtom; + pub static nsGkAtoms_symmetric_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5tanh_E"] - pub static nsGkAtoms_tanh_: *mut nsIAtom; + pub static nsGkAtoms_tanh_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4tan_E"] - pub static nsGkAtoms_tan_: *mut nsIAtom; + pub static nsGkAtoms_tan_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8tendsto_E"] - pub static nsGkAtoms_tendsto_: *mut nsIAtom; + pub static nsGkAtoms_tendsto_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6times_E"] - pub static nsGkAtoms_times_: *mut nsIAtom; + pub static nsGkAtoms_times_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10transpose_E"] - pub static nsGkAtoms_transpose_: *mut nsIAtom; + pub static nsGkAtoms_transpose_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6union_E"] - pub static nsGkAtoms_union_: *mut nsIAtom; + pub static nsGkAtoms_union_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8uplimit_E"] - pub static nsGkAtoms_uplimit_: *mut nsIAtom; + pub static nsGkAtoms_uplimit_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9variance_E"] - pub static nsGkAtoms_variance_: *mut nsIAtom; + pub static nsGkAtoms_variance_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14vectorproduct_E"] - pub static nsGkAtoms_vectorproduct_: *mut nsIAtom; + pub static nsGkAtoms_vectorproduct_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7vector_E"] - pub static nsGkAtoms_vector_: *mut nsIAtom; + pub static nsGkAtoms_vector_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8voffset_E"] - pub static nsGkAtoms_voffset_: *mut nsIAtom; + pub static nsGkAtoms_voffset_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5xref_E"] - pub static nsGkAtoms_xref_: *mut nsIAtom; + pub static nsGkAtoms_xref_: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4mathE"] - pub static nsGkAtoms_math: *mut nsIAtom; + pub static nsGkAtoms_math: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3avgE"] - pub static nsGkAtoms_avg: *mut nsIAtom; + pub static nsGkAtoms_avg: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17booleanFromStringE"] - pub static nsGkAtoms_booleanFromString: *mut nsIAtom; + pub static nsGkAtoms_booleanFromString: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13countNonEmptyE"] - pub static nsGkAtoms_countNonEmpty: *mut nsIAtom; + pub static nsGkAtoms_countNonEmpty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12daysFromDateE"] - pub static nsGkAtoms_daysFromDate: *mut nsIAtom; + pub static nsGkAtoms_daysFromDate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4initE"] - pub static nsGkAtoms_init: *mut nsIAtom; + pub static nsGkAtoms_init: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8instanceE"] - pub static nsGkAtoms_instance: *mut nsIAtom; + pub static nsGkAtoms_instance: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6monthsE"] - pub static nsGkAtoms_months: *mut nsIAtom; + pub static nsGkAtoms_months: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3nowE"] - pub static nsGkAtoms_now: *mut nsIAtom; + pub static nsGkAtoms_now: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7secondsE"] - pub static nsGkAtoms_seconds: *mut nsIAtom; + pub static nsGkAtoms_seconds: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19secondsFromDateTimeE"] - pub static nsGkAtoms_secondsFromDateTime: *mut nsIAtom; + pub static nsGkAtoms_secondsFromDateTime: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms25onMozSwipeGestureMayStartE"] - pub static nsGkAtoms_onMozSwipeGestureMayStart: *mut nsIAtom; + pub static nsGkAtoms_onMozSwipeGestureMayStart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms22onMozSwipeGestureStartE"] - pub static nsGkAtoms_onMozSwipeGestureStart: *mut nsIAtom; + pub static nsGkAtoms_onMozSwipeGestureStart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23onMozSwipeGestureUpdateE"] - pub static nsGkAtoms_onMozSwipeGestureUpdate: *mut nsIAtom; + pub static nsGkAtoms_onMozSwipeGestureUpdate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20onMozSwipeGestureEndE"] - pub static nsGkAtoms_onMozSwipeGestureEnd: *mut nsIAtom; + pub static nsGkAtoms_onMozSwipeGestureEnd: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17onMozSwipeGestureE"] - pub static nsGkAtoms_onMozSwipeGesture: *mut nsIAtom; + pub static nsGkAtoms_onMozSwipeGesture: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24onMozMagnifyGestureStartE"] - pub static nsGkAtoms_onMozMagnifyGestureStart: *mut nsIAtom; + pub static nsGkAtoms_onMozMagnifyGestureStart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms25onMozMagnifyGestureUpdateE"] - pub static nsGkAtoms_onMozMagnifyGestureUpdate: *mut nsIAtom; + pub static nsGkAtoms_onMozMagnifyGestureUpdate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19onMozMagnifyGestureE"] - pub static nsGkAtoms_onMozMagnifyGesture: *mut nsIAtom; + pub static nsGkAtoms_onMozMagnifyGesture: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23onMozRotateGestureStartE"] - pub static nsGkAtoms_onMozRotateGestureStart: *mut nsIAtom; + pub static nsGkAtoms_onMozRotateGestureStart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24onMozRotateGestureUpdateE"] - pub static nsGkAtoms_onMozRotateGestureUpdate: *mut nsIAtom; + pub static nsGkAtoms_onMozRotateGestureUpdate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18onMozRotateGestureE"] - pub static nsGkAtoms_onMozRotateGesture: *mut nsIAtom; + pub static nsGkAtoms_onMozRotateGesture: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15onMozTapGestureE"] - pub static nsGkAtoms_onMozTapGesture: *mut nsIAtom; + pub static nsGkAtoms_onMozTapGesture: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20onMozPressTapGestureE"] - pub static nsGkAtoms_onMozPressTapGesture: *mut nsIAtom; + pub static nsGkAtoms_onMozPressTapGesture: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18onMozEdgeUIStartedE"] - pub static nsGkAtoms_onMozEdgeUIStarted: *mut nsIAtom; + pub static nsGkAtoms_onMozEdgeUIStarted: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19onMozEdgeUICanceledE"] - pub static nsGkAtoms_onMozEdgeUICanceled: *mut nsIAtom; + pub static nsGkAtoms_onMozEdgeUICanceled: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20onMozEdgeUICompletedE"] - pub static nsGkAtoms_onMozEdgeUICompleted: *mut nsIAtom; + pub static nsGkAtoms_onMozEdgeUICompleted: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onpointerdownE"] - pub static nsGkAtoms_onpointerdown: *mut nsIAtom; + pub static nsGkAtoms_onpointerdown: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onpointermoveE"] - pub static nsGkAtoms_onpointermove: *mut nsIAtom; + pub static nsGkAtoms_onpointermove: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11onpointerupE"] - pub static nsGkAtoms_onpointerup: *mut nsIAtom; + pub static nsGkAtoms_onpointerup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15onpointercancelE"] - pub static nsGkAtoms_onpointercancel: *mut nsIAtom; + pub static nsGkAtoms_onpointercancel: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onpointeroverE"] - pub static nsGkAtoms_onpointerover: *mut nsIAtom; + pub static nsGkAtoms_onpointerover: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onpointeroutE"] - pub static nsGkAtoms_onpointerout: *mut nsIAtom; + pub static nsGkAtoms_onpointerout: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14onpointerenterE"] - pub static nsGkAtoms_onpointerenter: *mut nsIAtom; + pub static nsGkAtoms_onpointerenter: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14onpointerleaveE"] - pub static nsGkAtoms_onpointerleave: *mut nsIAtom; + pub static nsGkAtoms_onpointerleave: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19ongotpointercaptureE"] - pub static nsGkAtoms_ongotpointercapture: *mut nsIAtom; + pub static nsGkAtoms_ongotpointercapture: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20onlostpointercaptureE"] - pub static nsGkAtoms_onlostpointercapture: *mut nsIAtom; + pub static nsGkAtoms_onlostpointercapture: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14ondevicemotionE"] - pub static nsGkAtoms_ondevicemotion: *mut nsIAtom; + pub static nsGkAtoms_ondevicemotion: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19ondeviceorientationE"] - pub static nsGkAtoms_ondeviceorientation: *mut nsIAtom; + pub static nsGkAtoms_ondeviceorientation: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms27onabsolutedeviceorientationE"] - pub static nsGkAtoms_onabsolutedeviceorientation: *mut nsIAtom; + pub static nsGkAtoms_onabsolutedeviceorientation: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17ondeviceproximityE"] - pub static nsGkAtoms_ondeviceproximity: *mut nsIAtom; + pub static nsGkAtoms_ondeviceproximity: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms22onmozorientationchangeE"] - pub static nsGkAtoms_onmozorientationchange: *mut nsIAtom; + pub static nsGkAtoms_onmozorientationchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15onuserproximityE"] - pub static nsGkAtoms_onuserproximity: *mut nsIAtom; + pub static nsGkAtoms_onuserproximity: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13ondevicelightE"] - pub static nsGkAtoms_ondevicelight: *mut nsIAtom; + pub static nsGkAtoms_ondevicelight: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14ondevicechangeE"] - pub static nsGkAtoms_ondevicechange: *mut nsIAtom; + pub static nsGkAtoms_ondevicechange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms33mozinputrangeignorepreventdefaultE"] - pub static nsGkAtoms_mozinputrangeignorepreventdefault: *mut nsIAtom; + pub static nsGkAtoms_mozinputrangeignorepreventdefault: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13moz_extensionE"] - pub static nsGkAtoms_moz_extension: *mut nsIAtom; + pub static nsGkAtoms_moz_extension: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18all_urlsPermissionE"] - pub static nsGkAtoms_all_urlsPermission: *mut nsIAtom; + pub static nsGkAtoms_all_urlsPermission: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13clipboardReadE"] - pub static nsGkAtoms_clipboardRead: *mut nsIAtom; + pub static nsGkAtoms_clipboardRead: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14clipboardWriteE"] - pub static nsGkAtoms_clipboardWrite: *mut nsIAtom; + pub static nsGkAtoms_clipboardWrite: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8debuggerE"] - pub static nsGkAtoms_debugger: *mut nsIAtom; + pub static nsGkAtoms_debugger: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4tabsE"] - pub static nsGkAtoms_tabs: *mut nsIAtom; + pub static nsGkAtoms_tabs: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18webRequestBlockingE"] - pub static nsGkAtoms_webRequestBlocking: *mut nsIAtom; + pub static nsGkAtoms_webRequestBlocking: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4httpE"] - pub static nsGkAtoms_http: *mut nsIAtom; + pub static nsGkAtoms_http: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5httpsE"] - pub static nsGkAtoms_https: *mut nsIAtom; + pub static nsGkAtoms_https: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5proxyE"] - pub static nsGkAtoms_proxy: *mut nsIAtom; + pub static nsGkAtoms_proxy: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12cdataTagNameE"] - pub static nsGkAtoms_cdataTagName: *mut nsIAtom; + pub static nsGkAtoms_cdataTagName: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14commentTagNameE"] - pub static nsGkAtoms_commentTagName: *mut nsIAtom; + pub static nsGkAtoms_commentTagName: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16documentNodeNameE"] - pub static nsGkAtoms_documentNodeName: *mut nsIAtom; + pub static nsGkAtoms_documentNodeName: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24documentFragmentNodeNameE"] - pub static nsGkAtoms_documentFragmentNodeName: *mut nsIAtom; + pub static nsGkAtoms_documentFragmentNodeName: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20documentTypeNodeNameE"] - pub static nsGkAtoms_documentTypeNodeName: *mut nsIAtom; + pub static nsGkAtoms_documentTypeNodeName: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms28processingInstructionTagNameE"] - pub static nsGkAtoms_processingInstructionTagName: *mut nsIAtom; + pub static nsGkAtoms_processingInstructionTagName: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11textTagNameE"] - pub static nsGkAtoms_textTagName: *mut nsIAtom; + pub static nsGkAtoms_textTagName: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16placeholderFrameE"] - pub static nsGkAtoms_placeholderFrame: *mut nsIAtom; + pub static nsGkAtoms_placeholderFrame: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onloadendE"] - pub static nsGkAtoms_onloadend: *mut nsIAtom; + pub static nsGkAtoms_onloadend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11onloadstartE"] - pub static nsGkAtoms_onloadstart: *mut nsIAtom; + pub static nsGkAtoms_onloadstart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onprogressE"] - pub static nsGkAtoms_onprogress: *mut nsIAtom; + pub static nsGkAtoms_onprogress: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onsuspendE"] - pub static nsGkAtoms_onsuspend: *mut nsIAtom; + pub static nsGkAtoms_onsuspend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onemptiedE"] - pub static nsGkAtoms_onemptied: *mut nsIAtom; + pub static nsGkAtoms_onemptied: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onstalledE"] - pub static nsGkAtoms_onstalled: *mut nsIAtom; + pub static nsGkAtoms_onstalled: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6onplayE"] - pub static nsGkAtoms_onplay: *mut nsIAtom; + pub static nsGkAtoms_onplay: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7onpauseE"] - pub static nsGkAtoms_onpause: *mut nsIAtom; + pub static nsGkAtoms_onpause: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16onloadedmetadataE"] - pub static nsGkAtoms_onloadedmetadata: *mut nsIAtom; + pub static nsGkAtoms_onloadedmetadata: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onloadeddataE"] - pub static nsGkAtoms_onloadeddata: *mut nsIAtom; + pub static nsGkAtoms_onloadeddata: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onwaitingE"] - pub static nsGkAtoms_onwaiting: *mut nsIAtom; + pub static nsGkAtoms_onwaiting: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onplayingE"] - pub static nsGkAtoms_onplaying: *mut nsIAtom; + pub static nsGkAtoms_onplaying: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9oncanplayE"] - pub static nsGkAtoms_oncanplay: *mut nsIAtom; + pub static nsGkAtoms_oncanplay: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16oncanplaythroughE"] - pub static nsGkAtoms_oncanplaythrough: *mut nsIAtom; + pub static nsGkAtoms_oncanplaythrough: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onseekingE"] - pub static nsGkAtoms_onseeking: *mut nsIAtom; + pub static nsGkAtoms_onseeking: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8onseekedE"] - pub static nsGkAtoms_onseeked: *mut nsIAtom; + pub static nsGkAtoms_onseeked: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9ontimeoutE"] - pub static nsGkAtoms_ontimeout: *mut nsIAtom; + pub static nsGkAtoms_ontimeout: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12ontimeupdateE"] - pub static nsGkAtoms_ontimeupdate: *mut nsIAtom; + pub static nsGkAtoms_ontimeupdate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7onendedE"] - pub static nsGkAtoms_onended: *mut nsIAtom; + pub static nsGkAtoms_onended: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onratechangeE"] - pub static nsGkAtoms_onratechange: *mut nsIAtom; + pub static nsGkAtoms_onratechange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16ondurationchangeE"] - pub static nsGkAtoms_ondurationchange: *mut nsIAtom; + pub static nsGkAtoms_ondurationchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14onvolumechangeE"] - pub static nsGkAtoms_onvolumechange: *mut nsIAtom; + pub static nsGkAtoms_onvolumechange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onaddtrackE"] - pub static nsGkAtoms_onaddtrack: *mut nsIAtom; + pub static nsGkAtoms_onaddtrack: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18oncontrollerchangeE"] - pub static nsGkAtoms_oncontrollerchange: *mut nsIAtom; + pub static nsGkAtoms_oncontrollerchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11oncuechangeE"] - pub static nsGkAtoms_oncuechange: *mut nsIAtom; + pub static nsGkAtoms_oncuechange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7onenterE"] - pub static nsGkAtoms_onenter: *mut nsIAtom; + pub static nsGkAtoms_onenter: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6onexitE"] - pub static nsGkAtoms_onexit: *mut nsIAtom; + pub static nsGkAtoms_onexit: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11onencryptedE"] - pub static nsGkAtoms_onencrypted: *mut nsIAtom; + pub static nsGkAtoms_onencrypted: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9encryptedE"] - pub static nsGkAtoms_encrypted: *mut nsIAtom; + pub static nsGkAtoms_encrypted: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15onwaitingforkeyE"] - pub static nsGkAtoms_onwaitingforkey: *mut nsIAtom; + pub static nsGkAtoms_onwaitingforkey: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19onkeystatuseschangeE"] - pub static nsGkAtoms_onkeystatuseschange: *mut nsIAtom; + pub static nsGkAtoms_onkeystatuseschange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onremovetrackE"] - pub static nsGkAtoms_onremovetrack: *mut nsIAtom; + pub static nsGkAtoms_onremovetrack: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9loadstartE"] - pub static nsGkAtoms_loadstart: *mut nsIAtom; + pub static nsGkAtoms_loadstart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7suspendE"] - pub static nsGkAtoms_suspend: *mut nsIAtom; + pub static nsGkAtoms_suspend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7emptiedE"] - pub static nsGkAtoms_emptied: *mut nsIAtom; + pub static nsGkAtoms_emptied: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7stalledE"] - pub static nsGkAtoms_stalled: *mut nsIAtom; + pub static nsGkAtoms_stalled: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4playE"] - pub static nsGkAtoms_play: *mut nsIAtom; + pub static nsGkAtoms_play: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5pauseE"] - pub static nsGkAtoms_pause: *mut nsIAtom; + pub static nsGkAtoms_pause: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14loadedmetadataE"] - pub static nsGkAtoms_loadedmetadata: *mut nsIAtom; + pub static nsGkAtoms_loadedmetadata: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10loadeddataE"] - pub static nsGkAtoms_loadeddata: *mut nsIAtom; + pub static nsGkAtoms_loadeddata: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7waitingE"] - pub static nsGkAtoms_waiting: *mut nsIAtom; + pub static nsGkAtoms_waiting: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7playingE"] - pub static nsGkAtoms_playing: *mut nsIAtom; + pub static nsGkAtoms_playing: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7seekingE"] - pub static nsGkAtoms_seeking: *mut nsIAtom; + pub static nsGkAtoms_seeking: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6seekedE"] - pub static nsGkAtoms_seeked: *mut nsIAtom; + pub static nsGkAtoms_seeked: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10timeupdateE"] - pub static nsGkAtoms_timeupdate: *mut nsIAtom; + pub static nsGkAtoms_timeupdate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5endedE"] - pub static nsGkAtoms_ended: *mut nsIAtom; + pub static nsGkAtoms_ended: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7canplayE"] - pub static nsGkAtoms_canplay: *mut nsIAtom; + pub static nsGkAtoms_canplay: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14canplaythroughE"] - pub static nsGkAtoms_canplaythrough: *mut nsIAtom; + pub static nsGkAtoms_canplaythrough: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10ratechangeE"] - pub static nsGkAtoms_ratechange: *mut nsIAtom; + pub static nsGkAtoms_ratechange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14durationchangeE"] - pub static nsGkAtoms_durationchange: *mut nsIAtom; + pub static nsGkAtoms_durationchange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12volumechangeE"] - pub static nsGkAtoms_volumechange: *mut nsIAtom; + pub static nsGkAtoms_volumechange: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15ondataavailableE"] - pub static nsGkAtoms_ondataavailable: *mut nsIAtom; + pub static nsGkAtoms_ondataavailable: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onwarningE"] - pub static nsGkAtoms_onwarning: *mut nsIAtom; + pub static nsGkAtoms_onwarning: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7onstartE"] - pub static nsGkAtoms_onstart: *mut nsIAtom; + pub static nsGkAtoms_onstart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6onstopE"] - pub static nsGkAtoms_onstop: *mut nsIAtom; + pub static nsGkAtoms_onstop: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7onphotoE"] - pub static nsGkAtoms_onphoto: *mut nsIAtom; + pub static nsGkAtoms_onphoto: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20onactivestatechangedE"] - pub static nsGkAtoms_onactivestatechanged: *mut nsIAtom; + pub static nsGkAtoms_onactivestatechanged: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19ongamepadbuttondownE"] - pub static nsGkAtoms_ongamepadbuttondown: *mut nsIAtom; + pub static nsGkAtoms_ongamepadbuttondown: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17ongamepadbuttonupE"] - pub static nsGkAtoms_ongamepadbuttonup: *mut nsIAtom; + pub static nsGkAtoms_ongamepadbuttonup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17ongamepadaxismoveE"] - pub static nsGkAtoms_ongamepadaxismove: *mut nsIAtom; + pub static nsGkAtoms_ongamepadaxismove: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18ongamepadconnectedE"] - pub static nsGkAtoms_ongamepadconnected: *mut nsIAtom; + pub static nsGkAtoms_ongamepadconnected: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21ongamepaddisconnectedE"] - pub static nsGkAtoms_ongamepaddisconnected: *mut nsIAtom; + pub static nsGkAtoms_ongamepaddisconnected: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19afterPseudoPropertyE"] - pub static nsGkAtoms_afterPseudoProperty: *mut nsIAtom; + pub static nsGkAtoms_afterPseudoProperty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18animationsPropertyE"] - pub static nsGkAtoms_animationsProperty: *mut nsIAtom; + pub static nsGkAtoms_animationsProperty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms26animationsOfBeforePropertyE"] - pub static nsGkAtoms_animationsOfBeforeProperty: *mut nsIAtom; + pub static nsGkAtoms_animationsOfBeforeProperty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms25animationsOfAfterPropertyE"] - pub static nsGkAtoms_animationsOfAfterProperty: *mut nsIAtom; + pub static nsGkAtoms_animationsOfAfterProperty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24animationEffectsPropertyE"] - pub static nsGkAtoms_animationEffectsProperty: *mut nsIAtom; + pub static nsGkAtoms_animationEffectsProperty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms33animationEffectsForBeforePropertyE"] - pub static nsGkAtoms_animationEffectsForBeforeProperty: *mut nsIAtom; + pub static nsGkAtoms_animationEffectsForBeforeProperty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms32animationEffectsForAfterPropertyE"] - pub static nsGkAtoms_animationEffectsForAfterProperty: *mut nsIAtom; + pub static nsGkAtoms_animationEffectsForAfterProperty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20beforePseudoPropertyE"] - pub static nsGkAtoms_beforePseudoProperty: *mut nsIAtom; + pub static nsGkAtoms_beforePseudoProperty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms30cssPseudoElementBeforePropertyE"] - pub static nsGkAtoms_cssPseudoElementBeforeProperty: *mut nsIAtom; + pub static nsGkAtoms_cssPseudoElementBeforeProperty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms29cssPseudoElementAfterPropertyE"] - pub static nsGkAtoms_cssPseudoElementAfterProperty: *mut nsIAtom; + pub static nsGkAtoms_cssPseudoElementAfterProperty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19transitionsPropertyE"] - pub static nsGkAtoms_transitionsProperty: *mut nsIAtom; + pub static nsGkAtoms_transitionsProperty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms27transitionsOfBeforePropertyE"] - pub static nsGkAtoms_transitionsOfBeforeProperty: *mut nsIAtom; + pub static nsGkAtoms_transitionsOfBeforeProperty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms26transitionsOfAfterPropertyE"] - pub static nsGkAtoms_transitionsOfAfterProperty: *mut nsIAtom; + pub static nsGkAtoms_transitionsOfAfterProperty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms25genConInitializerPropertyE"] - pub static nsGkAtoms_genConInitializerProperty: *mut nsIAtom; + pub static nsGkAtoms_genConInitializerProperty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24labelMouseDownPtPropertyE"] - pub static nsGkAtoms_labelMouseDownPtProperty: *mut nsIAtom; + pub static nsGkAtoms_labelMouseDownPtProperty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17lockedStyleStatesE"] - pub static nsGkAtoms_lockedStyleStates: *mut nsIAtom; + pub static nsGkAtoms_lockedStyleStates: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20apzCallbackTransformE"] - pub static nsGkAtoms_apzCallbackTransform: *mut nsIAtom; + pub static nsGkAtoms_apzCallbackTransform: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23restylableAnonymousNodeE"] - pub static nsGkAtoms_restylableAnonymousNode: *mut nsIAtom; + pub static nsGkAtoms_restylableAnonymousNode: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16paintRequestTimeE"] - pub static nsGkAtoms_paintRequestTime: *mut nsIAtom; + pub static nsGkAtoms_paintRequestTime: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14pseudoPropertyE"] - pub static nsGkAtoms_pseudoProperty: *mut nsIAtom; + pub static nsGkAtoms_pseudoProperty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17manualNACPropertyE"] - pub static nsGkAtoms_manualNACProperty: *mut nsIAtom; + pub static nsGkAtoms_manualNACProperty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8JapaneseE"] - pub static nsGkAtoms_Japanese: *mut nsIAtom; + pub static nsGkAtoms_Japanese: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7ChineseE"] - pub static nsGkAtoms_Chinese: *mut nsIAtom; + pub static nsGkAtoms_Chinese: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9TaiwaneseE"] - pub static nsGkAtoms_Taiwanese: *mut nsIAtom; + pub static nsGkAtoms_Taiwanese: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15HongKongChineseE"] - pub static nsGkAtoms_HongKongChinese: *mut nsIAtom; + pub static nsGkAtoms_HongKongChinese: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7UnicodeE"] - pub static nsGkAtoms_Unicode: *mut nsIAtom; + pub static nsGkAtoms_Unicode: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2koE"] - pub static nsGkAtoms_ko: *mut nsIAtom; + pub static nsGkAtoms_ko: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5zh_cnE"] - pub static nsGkAtoms_zh_cn: *mut nsIAtom; + pub static nsGkAtoms_zh_cn: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5zh_hkE"] - pub static nsGkAtoms_zh_hk: *mut nsIAtom; + pub static nsGkAtoms_zh_hk: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5zh_twE"] - pub static nsGkAtoms_zh_tw: *mut nsIAtom; + pub static nsGkAtoms_zh_tw: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10x_cyrillicE"] - pub static nsGkAtoms_x_cyrillic: *mut nsIAtom; + pub static nsGkAtoms_x_cyrillic: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2heE"] - pub static nsGkAtoms_he: *mut nsIAtom; + pub static nsGkAtoms_he: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2arE"] - pub static nsGkAtoms_ar: *mut nsIAtom; + pub static nsGkAtoms_ar: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12x_devanagariE"] - pub static nsGkAtoms_x_devanagari: *mut nsIAtom; + pub static nsGkAtoms_x_devanagari: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7x_tamilE"] - pub static nsGkAtoms_x_tamil: *mut nsIAtom; + pub static nsGkAtoms_x_tamil: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6x_armnE"] - pub static nsGkAtoms_x_armn: *mut nsIAtom; + pub static nsGkAtoms_x_armn: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6x_bengE"] - pub static nsGkAtoms_x_beng: *mut nsIAtom; + pub static nsGkAtoms_x_beng: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6x_cansE"] - pub static nsGkAtoms_x_cans: *mut nsIAtom; + pub static nsGkAtoms_x_cans: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6x_ethiE"] - pub static nsGkAtoms_x_ethi: *mut nsIAtom; + pub static nsGkAtoms_x_ethi: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6x_georE"] - pub static nsGkAtoms_x_geor: *mut nsIAtom; + pub static nsGkAtoms_x_geor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6x_gujrE"] - pub static nsGkAtoms_x_gujr: *mut nsIAtom; + pub static nsGkAtoms_x_gujr: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6x_guruE"] - pub static nsGkAtoms_x_guru: *mut nsIAtom; + pub static nsGkAtoms_x_guru: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6x_khmrE"] - pub static nsGkAtoms_x_khmr: *mut nsIAtom; + pub static nsGkAtoms_x_khmr: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6x_kndaE"] - pub static nsGkAtoms_x_knda: *mut nsIAtom; + pub static nsGkAtoms_x_knda: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6x_mlymE"] - pub static nsGkAtoms_x_mlym: *mut nsIAtom; + pub static nsGkAtoms_x_mlym: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6x_oryaE"] - pub static nsGkAtoms_x_orya: *mut nsIAtom; + pub static nsGkAtoms_x_orya: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6x_sinhE"] - pub static nsGkAtoms_x_sinh: *mut nsIAtom; + pub static nsGkAtoms_x_sinh: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6x_teluE"] - pub static nsGkAtoms_x_telu: *mut nsIAtom; + pub static nsGkAtoms_x_telu: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6x_tibtE"] - pub static nsGkAtoms_x_tibt: *mut nsIAtom; + pub static nsGkAtoms_x_tibt: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2azE"] - pub static nsGkAtoms_az: *mut nsIAtom; + pub static nsGkAtoms_az: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2baE"] - pub static nsGkAtoms_ba: *mut nsIAtom; + pub static nsGkAtoms_ba: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3crhE"] - pub static nsGkAtoms_crh: *mut nsIAtom; + pub static nsGkAtoms_crh: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2elE"] - pub static nsGkAtoms_el: *mut nsIAtom; + pub static nsGkAtoms_el: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2gaE"] - pub static nsGkAtoms_ga: *mut nsIAtom; + pub static nsGkAtoms_ga: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms2nlE"] - pub static nsGkAtoms_nl: *mut nsIAtom; + pub static nsGkAtoms_nl: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6x_mathE"] - pub static nsGkAtoms_x_math: *mut nsIAtom; + pub static nsGkAtoms_x_math: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13TypingTxnNameE"] - pub static nsGkAtoms_TypingTxnName: *mut nsIAtom; + pub static nsGkAtoms_TypingTxnName: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10IMETxnNameE"] - pub static nsGkAtoms_IMETxnName: *mut nsIAtom; + pub static nsGkAtoms_IMETxnName: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13DeleteTxnNameE"] - pub static nsGkAtoms_DeleteTxnName: *mut nsIAtom; + pub static nsGkAtoms_DeleteTxnName: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5serifE"] - pub static nsGkAtoms_serif: *mut nsIAtom; + pub static nsGkAtoms_serif: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10sans_serifE"] - pub static nsGkAtoms_sans_serif: *mut nsIAtom; + pub static nsGkAtoms_sans_serif: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7cursiveE"] - pub static nsGkAtoms_cursive: *mut nsIAtom; + pub static nsGkAtoms_cursive: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7fantasyE"] - pub static nsGkAtoms_fantasy: *mut nsIAtom; + pub static nsGkAtoms_fantasy: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9monospaceE"] - pub static nsGkAtoms_monospace: *mut nsIAtom; + pub static nsGkAtoms_monospace: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8mozfixedE"] - pub static nsGkAtoms_mozfixed: *mut nsIAtom; + pub static nsGkAtoms_mozfixed: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6RemoteE"] - pub static nsGkAtoms_Remote: *mut nsIAtom; + pub static nsGkAtoms_Remote: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8RemoteIdE"] - pub static nsGkAtoms_RemoteId: *mut nsIAtom; + pub static nsGkAtoms_RemoteId: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10RemoteTypeE"] - pub static nsGkAtoms_RemoteType: *mut nsIAtom; + pub static nsGkAtoms_RemoteType: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11DisplayPortE"] - pub static nsGkAtoms_DisplayPort: *mut nsIAtom; + pub static nsGkAtoms_DisplayPort: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18DisplayPortMarginsE"] - pub static nsGkAtoms_DisplayPortMargins: *mut nsIAtom; + pub static nsGkAtoms_DisplayPortMargins: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15DisplayPortBaseE"] - pub static nsGkAtoms_DisplayPortBase: *mut nsIAtom; + pub static nsGkAtoms_DisplayPortBase: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms30AsyncScrollLayerCreationFailedE"] - pub static nsGkAtoms_AsyncScrollLayerCreationFailed: *mut nsIAtom; + pub static nsGkAtoms_AsyncScrollLayerCreationFailed: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19forcemessagemanagerE"] - pub static nsGkAtoms_forcemessagemanager: *mut nsIAtom; + pub static nsGkAtoms_forcemessagemanager: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16isPreloadBrowserE"] - pub static nsGkAtoms_isPreloadBrowser: *mut nsIAtom; + pub static nsGkAtoms_isPreloadBrowser: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms22color_picker_availableE"] - pub static nsGkAtoms_color_picker_available: *mut nsIAtom; + pub static nsGkAtoms_color_picker_available: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24scrollbar_start_backwardE"] - pub static nsGkAtoms_scrollbar_start_backward: *mut nsIAtom; + pub static nsGkAtoms_scrollbar_start_backward: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23scrollbar_start_forwardE"] - pub static nsGkAtoms_scrollbar_start_forward: *mut nsIAtom; + pub static nsGkAtoms_scrollbar_start_forward: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms22scrollbar_end_backwardE"] - pub static nsGkAtoms_scrollbar_end_backward: *mut nsIAtom; + pub static nsGkAtoms_scrollbar_end_backward: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21scrollbar_end_forwardE"] - pub static nsGkAtoms_scrollbar_end_forward: *mut nsIAtom; + pub static nsGkAtoms_scrollbar_end_forward: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms28scrollbar_thumb_proportionalE"] - pub static nsGkAtoms_scrollbar_thumb_proportional: *mut nsIAtom; + pub static nsGkAtoms_scrollbar_thumb_proportional: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18overlay_scrollbarsE"] - pub static nsGkAtoms_overlay_scrollbars: *mut nsIAtom; + pub static nsGkAtoms_overlay_scrollbars: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms32windows_accent_color_in_titlebarE"] - pub static nsGkAtoms_windows_accent_color_in_titlebar: *mut nsIAtom; + pub static nsGkAtoms_windows_accent_color_in_titlebar: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21windows_default_themeE"] - pub static nsGkAtoms_windows_default_theme: *mut nsIAtom; + pub static nsGkAtoms_windows_default_theme: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18mac_graphite_themeE"] - pub static nsGkAtoms_mac_graphite_theme: *mut nsIAtom; + pub static nsGkAtoms_mac_graphite_theme: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18mac_yosemite_themeE"] - pub static nsGkAtoms_mac_yosemite_theme: *mut nsIAtom; + pub static nsGkAtoms_mac_yosemite_theme: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18windows_compositorE"] - pub static nsGkAtoms_windows_compositor: *mut nsIAtom; + pub static nsGkAtoms_windows_compositor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13windows_glassE"] - pub static nsGkAtoms_windows_glass: *mut nsIAtom; + pub static nsGkAtoms_windows_glass: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13touch_enabledE"] - pub static nsGkAtoms_touch_enabled: *mut nsIAtom; + pub static nsGkAtoms_touch_enabled: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12menubar_dragE"] - pub static nsGkAtoms_menubar_drag: *mut nsIAtom; + pub static nsGkAtoms_menubar_drag: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23swipe_animation_enabledE"] - pub static nsGkAtoms_swipe_animation_enabled: *mut nsIAtom; + pub static nsGkAtoms_swipe_animation_enabled: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20physical_home_buttonE"] - pub static nsGkAtoms_physical_home_button: *mut nsIAtom; + pub static nsGkAtoms_physical_home_button: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15windows_classicE"] - pub static nsGkAtoms_windows_classic: *mut nsIAtom; + pub static nsGkAtoms_windows_classic: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18windows_theme_aeroE"] - pub static nsGkAtoms_windows_theme_aero: *mut nsIAtom; + pub static nsGkAtoms_windows_theme_aero: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23windows_theme_aero_liteE"] - pub static nsGkAtoms_windows_theme_aero_lite: *mut nsIAtom; + pub static nsGkAtoms_windows_theme_aero_lite: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23windows_theme_luna_blueE"] - pub static nsGkAtoms_windows_theme_luna_blue: *mut nsIAtom; + pub static nsGkAtoms_windows_theme_luna_blue: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms24windows_theme_luna_oliveE"] - pub static nsGkAtoms_windows_theme_luna_olive: *mut nsIAtom; + pub static nsGkAtoms_windows_theme_luna_olive: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms25windows_theme_luna_silverE"] - pub static nsGkAtoms_windows_theme_luna_silver: *mut nsIAtom; + pub static nsGkAtoms_windows_theme_luna_silver: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20windows_theme_royaleE"] - pub static nsGkAtoms_windows_theme_royale: *mut nsIAtom; + pub static nsGkAtoms_windows_theme_royale: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18windows_theme_zuneE"] - pub static nsGkAtoms_windows_theme_zune: *mut nsIAtom; + pub static nsGkAtoms_windows_theme_zune: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms21windows_theme_genericE"] - pub static nsGkAtoms_windows_theme_generic: *mut nsIAtom; + pub static nsGkAtoms_windows_theme_generic: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms27_moz_color_picker_availableE"] - pub static nsGkAtoms__moz_color_picker_available: *mut nsIAtom; + pub static nsGkAtoms__moz_color_picker_available: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms29_moz_scrollbar_start_backwardE"] - pub static nsGkAtoms__moz_scrollbar_start_backward: *mut nsIAtom; + pub static nsGkAtoms__moz_scrollbar_start_backward: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms28_moz_scrollbar_start_forwardE"] - pub static nsGkAtoms__moz_scrollbar_start_forward: *mut nsIAtom; + pub static nsGkAtoms__moz_scrollbar_start_forward: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms27_moz_scrollbar_end_backwardE"] - pub static nsGkAtoms__moz_scrollbar_end_backward: *mut nsIAtom; + pub static nsGkAtoms__moz_scrollbar_end_backward: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms26_moz_scrollbar_end_forwardE"] - pub static nsGkAtoms__moz_scrollbar_end_forward: *mut nsIAtom; + pub static nsGkAtoms__moz_scrollbar_end_forward: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms33_moz_scrollbar_thumb_proportionalE"] - pub static nsGkAtoms__moz_scrollbar_thumb_proportional: *mut nsIAtom; + pub static nsGkAtoms__moz_scrollbar_thumb_proportional: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23_moz_overlay_scrollbarsE"] - pub static nsGkAtoms__moz_overlay_scrollbars: *mut nsIAtom; + pub static nsGkAtoms__moz_overlay_scrollbars: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms37_moz_windows_accent_color_in_titlebarE"] - pub static nsGkAtoms__moz_windows_accent_color_in_titlebar: *mut nsIAtom; + pub static nsGkAtoms__moz_windows_accent_color_in_titlebar: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms26_moz_windows_default_themeE"] - pub static nsGkAtoms__moz_windows_default_theme: *mut nsIAtom; + pub static nsGkAtoms__moz_windows_default_theme: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23_moz_mac_graphite_themeE"] - pub static nsGkAtoms__moz_mac_graphite_theme: *mut nsIAtom; + pub static nsGkAtoms__moz_mac_graphite_theme: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23_moz_mac_yosemite_themeE"] - pub static nsGkAtoms__moz_mac_yosemite_theme: *mut nsIAtom; + pub static nsGkAtoms__moz_mac_yosemite_theme: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23_moz_windows_compositorE"] - pub static nsGkAtoms__moz_windows_compositor: *mut nsIAtom; + pub static nsGkAtoms__moz_windows_compositor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20_moz_windows_classicE"] - pub static nsGkAtoms__moz_windows_classic: *mut nsIAtom; + pub static nsGkAtoms__moz_windows_classic: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18_moz_windows_glassE"] - pub static nsGkAtoms__moz_windows_glass: *mut nsIAtom; + pub static nsGkAtoms__moz_windows_glass: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18_moz_windows_themeE"] - pub static nsGkAtoms__moz_windows_theme: *mut nsIAtom; + pub static nsGkAtoms__moz_windows_theme: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15_moz_os_versionE"] - pub static nsGkAtoms__moz_os_version: *mut nsIAtom; + pub static nsGkAtoms__moz_os_version: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18_moz_touch_enabledE"] - pub static nsGkAtoms__moz_touch_enabled: *mut nsIAtom; + pub static nsGkAtoms__moz_touch_enabled: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17_moz_menubar_dragE"] - pub static nsGkAtoms__moz_menubar_drag: *mut nsIAtom; + pub static nsGkAtoms__moz_menubar_drag: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23_moz_device_pixel_ratioE"] - pub static nsGkAtoms__moz_device_pixel_ratio: *mut nsIAtom; + pub static nsGkAtoms__moz_device_pixel_ratio: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms23_moz_device_orientationE"] - pub static nsGkAtoms__moz_device_orientation: *mut nsIAtom; + pub static nsGkAtoms__moz_device_orientation: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms25_moz_is_resource_documentE"] - pub static nsGkAtoms__moz_is_resource_document: *mut nsIAtom; + pub static nsGkAtoms__moz_is_resource_document: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms28_moz_swipe_animation_enabledE"] - pub static nsGkAtoms__moz_swipe_animation_enabled: *mut nsIAtom; + pub static nsGkAtoms__moz_swipe_animation_enabled: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms25_moz_physical_home_buttonE"] - pub static nsGkAtoms__moz_physical_home_button: *mut nsIAtom; + pub static nsGkAtoms__moz_physical_home_button: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4BackE"] - pub static nsGkAtoms_Back: *mut nsIAtom; + pub static nsGkAtoms_Back: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7ForwardE"] - pub static nsGkAtoms_Forward: *mut nsIAtom; + pub static nsGkAtoms_Forward: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6ReloadE"] - pub static nsGkAtoms_Reload: *mut nsIAtom; + pub static nsGkAtoms_Reload: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4StopE"] - pub static nsGkAtoms_Stop: *mut nsIAtom; + pub static nsGkAtoms_Stop: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6SearchE"] - pub static nsGkAtoms_Search: *mut nsIAtom; + pub static nsGkAtoms_Search: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9BookmarksE"] - pub static nsGkAtoms_Bookmarks: *mut nsIAtom; + pub static nsGkAtoms_Bookmarks: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4HomeE"] - pub static nsGkAtoms_Home: *mut nsIAtom; + pub static nsGkAtoms_Home: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5ClearE"] - pub static nsGkAtoms_Clear: *mut nsIAtom; + pub static nsGkAtoms_Clear: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8VolumeUpE"] - pub static nsGkAtoms_VolumeUp: *mut nsIAtom; + pub static nsGkAtoms_VolumeUp: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10VolumeDownE"] - pub static nsGkAtoms_VolumeDown: *mut nsIAtom; + pub static nsGkAtoms_VolumeDown: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9NextTrackE"] - pub static nsGkAtoms_NextTrack: *mut nsIAtom; + pub static nsGkAtoms_NextTrack: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13PreviousTrackE"] - pub static nsGkAtoms_PreviousTrack: *mut nsIAtom; + pub static nsGkAtoms_PreviousTrack: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9MediaStopE"] - pub static nsGkAtoms_MediaStop: *mut nsIAtom; + pub static nsGkAtoms_MediaStop: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9PlayPauseE"] - pub static nsGkAtoms_PlayPause: *mut nsIAtom; + pub static nsGkAtoms_PlayPause: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4MenuE"] - pub static nsGkAtoms_Menu: *mut nsIAtom; + pub static nsGkAtoms_Menu: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3NewE"] - pub static nsGkAtoms_New: *mut nsIAtom; + pub static nsGkAtoms_New: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4OpenE"] - pub static nsGkAtoms_Open: *mut nsIAtom; + pub static nsGkAtoms_Open: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5CloseE"] - pub static nsGkAtoms_Close: *mut nsIAtom; + pub static nsGkAtoms_Close: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4SaveE"] - pub static nsGkAtoms_Save: *mut nsIAtom; + pub static nsGkAtoms_Save: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4FindE"] - pub static nsGkAtoms_Find: *mut nsIAtom; + pub static nsGkAtoms_Find: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4HelpE"] - pub static nsGkAtoms_Help: *mut nsIAtom; + pub static nsGkAtoms_Help: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5PrintE"] - pub static nsGkAtoms_Print: *mut nsIAtom; + pub static nsGkAtoms_Print: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8SendMailE"] - pub static nsGkAtoms_SendMail: *mut nsIAtom; + pub static nsGkAtoms_SendMail: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11ForwardMailE"] - pub static nsGkAtoms_ForwardMail: *mut nsIAtom; + pub static nsGkAtoms_ForwardMail: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11ReplyToMailE"] - pub static nsGkAtoms_ReplyToMail: *mut nsIAtom; + pub static nsGkAtoms_ReplyToMail: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10mouseWheelE"] - pub static nsGkAtoms_mouseWheel: *mut nsIAtom; + pub static nsGkAtoms_mouseWheel: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6pixelsE"] - pub static nsGkAtoms_pixels: *mut nsIAtom; + pub static nsGkAtoms_pixels: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5linesE"] - pub static nsGkAtoms_lines: *mut nsIAtom; + pub static nsGkAtoms_lines: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5pagesE"] - pub static nsGkAtoms_pages: *mut nsIAtom; + pub static nsGkAtoms_pages: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10scrollbarsE"] - pub static nsGkAtoms_scrollbars: *mut nsIAtom; + pub static nsGkAtoms_scrollbars: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5otherE"] - pub static nsGkAtoms_other: *mut nsIAtom; + pub static nsGkAtoms_other: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms3apzE"] - pub static nsGkAtoms_apz: *mut nsIAtom; + pub static nsGkAtoms_apz: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7restoreE"] - pub static nsGkAtoms_restore: *mut nsIAtom; + pub static nsGkAtoms_restore: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5alertE"] - pub static nsGkAtoms_alert: *mut nsIAtom; + pub static nsGkAtoms_alert: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11alertdialogE"] - pub static nsGkAtoms_alertdialog: *mut nsIAtom; + pub static nsGkAtoms_alertdialog: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11applicationE"] - pub static nsGkAtoms_application: *mut nsIAtom; + pub static nsGkAtoms_application: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13aria_colcountE"] - pub static nsGkAtoms_aria_colcount: *mut nsIAtom; + pub static nsGkAtoms_aria_colcount: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13aria_colindexE"] - pub static nsGkAtoms_aria_colindex: *mut nsIAtom; + pub static nsGkAtoms_aria_colindex: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12aria_detailsE"] - pub static nsGkAtoms_aria_details: *mut nsIAtom; + pub static nsGkAtoms_aria_details: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17aria_errormessageE"] - pub static nsGkAtoms_aria_errormessage: *mut nsIAtom; + pub static nsGkAtoms_aria_errormessage: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12aria_grabbedE"] - pub static nsGkAtoms_aria_grabbed: *mut nsIAtom; + pub static nsGkAtoms_aria_grabbed: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10aria_labelE"] - pub static nsGkAtoms_aria_label: *mut nsIAtom; + pub static nsGkAtoms_aria_label: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10aria_modalE"] - pub static nsGkAtoms_aria_modal: *mut nsIAtom; + pub static nsGkAtoms_aria_modal: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16aria_orientationE"] - pub static nsGkAtoms_aria_orientation: *mut nsIAtom; + pub static nsGkAtoms_aria_orientation: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13aria_rowcountE"] - pub static nsGkAtoms_aria_rowcount: *mut nsIAtom; + pub static nsGkAtoms_aria_rowcount: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13aria_rowindexE"] - pub static nsGkAtoms_aria_rowindex: *mut nsIAtom; + pub static nsGkAtoms_aria_rowindex: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14aria_valuetextE"] - pub static nsGkAtoms_aria_valuetext: *mut nsIAtom; + pub static nsGkAtoms_aria_valuetext: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14auto_generatedE"] - pub static nsGkAtoms_auto_generated: *mut nsIAtom; + pub static nsGkAtoms_auto_generated: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6bannerE"] - pub static nsGkAtoms_banner: *mut nsIAtom; + pub static nsGkAtoms_banner: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9checkableE"] - pub static nsGkAtoms_checkable: *mut nsIAtom; + pub static nsGkAtoms_checkable: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7choicesE"] - pub static nsGkAtoms_choices: *mut nsIAtom; + pub static nsGkAtoms_choices: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12columnheaderE"] - pub static nsGkAtoms_columnheader: *mut nsIAtom; + pub static nsGkAtoms_columnheader: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13complementaryE"] - pub static nsGkAtoms_complementary: *mut nsIAtom; + pub static nsGkAtoms_complementary: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15containerAtomicE"] - pub static nsGkAtoms_containerAtomic: *mut nsIAtom; + pub static nsGkAtoms_containerAtomic: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13containerBusyE"] - pub static nsGkAtoms_containerBusy: *mut nsIAtom; + pub static nsGkAtoms_containerBusy: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13containerLiveE"] - pub static nsGkAtoms_containerLive: *mut nsIAtom; + pub static nsGkAtoms_containerLive: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17containerLiveRoleE"] - pub static nsGkAtoms_containerLiveRole: *mut nsIAtom; + pub static nsGkAtoms_containerLiveRole: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17containerRelevantE"] - pub static nsGkAtoms_containerRelevant: *mut nsIAtom; + pub static nsGkAtoms_containerRelevant: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11contentinfoE"] - pub static nsGkAtoms_contentinfo: *mut nsIAtom; + pub static nsGkAtoms_contentinfo: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6cyclesE"] - pub static nsGkAtoms_cycles: *mut nsIAtom; + pub static nsGkAtoms_cycles: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9datatableE"] - pub static nsGkAtoms_datatable: *mut nsIAtom; + pub static nsGkAtoms_datatable: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14eventFromInputE"] - pub static nsGkAtoms_eventFromInput: *mut nsIAtom; + pub static nsGkAtoms_eventFromInput: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4feedE"] - pub static nsGkAtoms_feed: *mut nsIAtom; + pub static nsGkAtoms_feed: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7grammarE"] - pub static nsGkAtoms_grammar: *mut nsIAtom; + pub static nsGkAtoms_grammar: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8gridcellE"] - pub static nsGkAtoms_gridcell: *mut nsIAtom; + pub static nsGkAtoms_gridcell: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7headingE"] - pub static nsGkAtoms_heading: *mut nsIAtom; + pub static nsGkAtoms_heading: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9hitregionE"] - pub static nsGkAtoms_hitregion: *mut nsIAtom; + pub static nsGkAtoms_hitregion: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11inlinevalueE"] - pub static nsGkAtoms_inlinevalue: *mut nsIAtom; + pub static nsGkAtoms_inlinevalue: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7invalidE"] - pub static nsGkAtoms_invalid: *mut nsIAtom; + pub static nsGkAtoms_invalid: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4itemE"] - pub static nsGkAtoms_item: *mut nsIAtom; + pub static nsGkAtoms_item: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7itemsetE"] - pub static nsGkAtoms_itemset: *mut nsIAtom; + pub static nsGkAtoms_itemset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10lineNumberE"] - pub static nsGkAtoms_lineNumber: *mut nsIAtom; + pub static nsGkAtoms_lineNumber: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11linkedPanelE"] - pub static nsGkAtoms_linkedPanel: *mut nsIAtom; + pub static nsGkAtoms_linkedPanel: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4liveE"] - pub static nsGkAtoms_live: *mut nsIAtom; + pub static nsGkAtoms_live: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16menuitemcheckboxE"] - pub static nsGkAtoms_menuitemcheckbox: *mut nsIAtom; + pub static nsGkAtoms_menuitemcheckbox: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13menuitemradioE"] - pub static nsGkAtoms_menuitemradio: *mut nsIAtom; + pub static nsGkAtoms_menuitemradio: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5mixedE"] - pub static nsGkAtoms_mixed: *mut nsIAtom; + pub static nsGkAtoms_mixed: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9multilineE"] - pub static nsGkAtoms_multiline: *mut nsIAtom; + pub static nsGkAtoms_multiline: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10navigationE"] - pub static nsGkAtoms_navigation: *mut nsIAtom; + pub static nsGkAtoms_navigation: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6politeE"] - pub static nsGkAtoms_polite: *mut nsIAtom; + pub static nsGkAtoms_polite: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8posinsetE"] - pub static nsGkAtoms_posinset: *mut nsIAtom; + pub static nsGkAtoms_posinset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12presentationE"] - pub static nsGkAtoms_presentation: *mut nsIAtom; + pub static nsGkAtoms_presentation: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11progressbarE"] - pub static nsGkAtoms_progressbar: *mut nsIAtom; + pub static nsGkAtoms_progressbar: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6regionE"] - pub static nsGkAtoms_region: *mut nsIAtom; + pub static nsGkAtoms_region: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8rowgroupE"] - pub static nsGkAtoms_rowgroup: *mut nsIAtom; + pub static nsGkAtoms_rowgroup: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9rowheaderE"] - pub static nsGkAtoms_rowheader: *mut nsIAtom; + pub static nsGkAtoms_rowheader: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6searchE"] - pub static nsGkAtoms_search: *mut nsIAtom; + pub static nsGkAtoms_search: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9searchboxE"] - pub static nsGkAtoms_searchbox: *mut nsIAtom; + pub static nsGkAtoms_searchbox: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7select1E"] - pub static nsGkAtoms_select1: *mut nsIAtom; + pub static nsGkAtoms_select1: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7setsizeE"] - pub static nsGkAtoms_setsize: *mut nsIAtom; + pub static nsGkAtoms_setsize: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8spellingE"] - pub static nsGkAtoms_spelling: *mut nsIAtom; + pub static nsGkAtoms_spelling: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10spinbuttonE"] - pub static nsGkAtoms_spinbutton: *mut nsIAtom; + pub static nsGkAtoms_spinbutton: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6statusE"] - pub static nsGkAtoms_status: *mut nsIAtom; + pub static nsGkAtoms_status: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14tableCellIndexE"] - pub static nsGkAtoms_tableCellIndex: *mut nsIAtom; + pub static nsGkAtoms_tableCellIndex: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7tablistE"] - pub static nsGkAtoms_tablist: *mut nsIAtom; + pub static nsGkAtoms_tablist: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10textIndentE"] - pub static nsGkAtoms_textIndent: *mut nsIAtom; + pub static nsGkAtoms_textIndent: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13textInputTypeE"] - pub static nsGkAtoms_textInputType: *mut nsIAtom; + pub static nsGkAtoms_textInputType: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20textLineThroughColorE"] - pub static nsGkAtoms_textLineThroughColor: *mut nsIAtom; + pub static nsGkAtoms_textLineThroughColor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20textLineThroughStyleE"] - pub static nsGkAtoms_textLineThroughStyle: *mut nsIAtom; + pub static nsGkAtoms_textLineThroughStyle: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12textPositionE"] - pub static nsGkAtoms_textPosition: *mut nsIAtom; + pub static nsGkAtoms_textPosition: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18textUnderlineColorE"] - pub static nsGkAtoms_textUnderlineColor: *mut nsIAtom; + pub static nsGkAtoms_textUnderlineColor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18textUnderlineStyleE"] - pub static nsGkAtoms_textUnderlineStyle: *mut nsIAtom; + pub static nsGkAtoms_textUnderlineStyle: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5timerE"] - pub static nsGkAtoms_timer: *mut nsIAtom; + pub static nsGkAtoms_timer: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11toolbarnameE"] - pub static nsGkAtoms_toolbarname: *mut nsIAtom; + pub static nsGkAtoms_toolbarname: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16toolbarseparatorE"] - pub static nsGkAtoms_toolbarseparator: *mut nsIAtom; + pub static nsGkAtoms_toolbarseparator: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13toolbarspacerE"] - pub static nsGkAtoms_toolbarspacer: *mut nsIAtom; + pub static nsGkAtoms_toolbarspacer: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13toolbarspringE"] - pub static nsGkAtoms_toolbarspring: *mut nsIAtom; + pub static nsGkAtoms_toolbarspring: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8treegridE"] - pub static nsGkAtoms_treegrid: *mut nsIAtom; + pub static nsGkAtoms_treegrid: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10_undefinedE"] - pub static nsGkAtoms__undefined: *mut nsIAtom; + pub static nsGkAtoms__undefined: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8xmlrolesE"] - pub static nsGkAtoms_xmlroles: *mut nsIAtom; + pub static nsGkAtoms_xmlroles: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11close_fenceE"] - pub static nsGkAtoms_close_fence: *mut nsIAtom; + pub static nsGkAtoms_close_fence: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11denominatorE"] - pub static nsGkAtoms_denominator: *mut nsIAtom; + pub static nsGkAtoms_denominator: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9numeratorE"] - pub static nsGkAtoms_numerator: *mut nsIAtom; + pub static nsGkAtoms_numerator: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10open_fenceE"] - pub static nsGkAtoms_open_fence: *mut nsIAtom; + pub static nsGkAtoms_open_fence: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10overscriptE"] - pub static nsGkAtoms_overscript: *mut nsIAtom; + pub static nsGkAtoms_overscript: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12presubscriptE"] - pub static nsGkAtoms_presubscript: *mut nsIAtom; + pub static nsGkAtoms_presubscript: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14presuperscriptE"] - pub static nsGkAtoms_presuperscript: *mut nsIAtom; + pub static nsGkAtoms_presuperscript: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10root_indexE"] - pub static nsGkAtoms_root_index: *mut nsIAtom; + pub static nsGkAtoms_root_index: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9subscriptE"] - pub static nsGkAtoms_subscript: *mut nsIAtom; + pub static nsGkAtoms_subscript: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11superscriptE"] - pub static nsGkAtoms_superscript: *mut nsIAtom; + pub static nsGkAtoms_superscript: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11underscriptE"] - pub static nsGkAtoms_underscript: *mut nsIAtom; + pub static nsGkAtoms_underscript: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onaudiostartE"] - pub static nsGkAtoms_onaudiostart: *mut nsIAtom; + pub static nsGkAtoms_onaudiostart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onaudioendE"] - pub static nsGkAtoms_onaudioend: *mut nsIAtom; + pub static nsGkAtoms_onaudioend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onsoundstartE"] - pub static nsGkAtoms_onsoundstart: *mut nsIAtom; + pub static nsGkAtoms_onsoundstart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onsoundendE"] - pub static nsGkAtoms_onsoundend: *mut nsIAtom; + pub static nsGkAtoms_onsoundend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onspeechstartE"] - pub static nsGkAtoms_onspeechstart: *mut nsIAtom; + pub static nsGkAtoms_onspeechstart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11onspeechendE"] - pub static nsGkAtoms_onspeechend: *mut nsIAtom; + pub static nsGkAtoms_onspeechend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8onresultE"] - pub static nsGkAtoms_onresult: *mut nsIAtom; + pub static nsGkAtoms_onresult: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9onnomatchE"] - pub static nsGkAtoms_onnomatch: *mut nsIAtom; + pub static nsGkAtoms_onnomatch: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8onresumeE"] - pub static nsGkAtoms_onresume: *mut nsIAtom; + pub static nsGkAtoms_onresume: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6onmarkE"] - pub static nsGkAtoms_onmark: *mut nsIAtom; + pub static nsGkAtoms_onmark: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10onboundaryE"] - pub static nsGkAtoms_onboundary: *mut nsIAtom; + pub static nsGkAtoms_onboundary: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13usercontextidE"] - pub static nsGkAtoms_usercontextid: *mut nsIAtom; + pub static nsGkAtoms_usercontextid: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11nsuri_xmlnsE"] - pub static nsGkAtoms_nsuri_xmlns: *mut nsIAtom; + pub static nsGkAtoms_nsuri_xmlns: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9nsuri_xmlE"] - pub static nsGkAtoms_nsuri_xml: *mut nsIAtom; + pub static nsGkAtoms_nsuri_xml: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11nsuri_xhtmlE"] - pub static nsGkAtoms_nsuri_xhtml: *mut nsIAtom; + pub static nsGkAtoms_nsuri_xhtml: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11nsuri_xlinkE"] - pub static nsGkAtoms_nsuri_xlink: *mut nsIAtom; + pub static nsGkAtoms_nsuri_xlink: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10nsuri_xsltE"] - pub static nsGkAtoms_nsuri_xslt: *mut nsIAtom; + pub static nsGkAtoms_nsuri_xslt: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9nsuri_xblE"] - pub static nsGkAtoms_nsuri_xbl: *mut nsIAtom; + pub static nsGkAtoms_nsuri_xbl: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12nsuri_mathmlE"] - pub static nsGkAtoms_nsuri_mathml: *mut nsIAtom; + pub static nsGkAtoms_nsuri_mathml: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9nsuri_rdfE"] - pub static nsGkAtoms_nsuri_rdf: *mut nsIAtom; + pub static nsGkAtoms_nsuri_rdf: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9nsuri_xulE"] - pub static nsGkAtoms_nsuri_xul: *mut nsIAtom; + pub static nsGkAtoms_nsuri_xul: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9nsuri_svgE"] - pub static nsGkAtoms_nsuri_svg: *mut nsIAtom; + pub static nsGkAtoms_nsuri_svg: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onsourceopenE"] - pub static nsGkAtoms_onsourceopen: *mut nsIAtom; + pub static nsGkAtoms_onsourceopen: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onsourceendedE"] - pub static nsGkAtoms_onsourceended: *mut nsIAtom; + pub static nsGkAtoms_onsourceended: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14onsourceclosedE"] - pub static nsGkAtoms_onsourceclosed: *mut nsIAtom; + pub static nsGkAtoms_onsourceclosed: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13onupdatestartE"] - pub static nsGkAtoms_onupdatestart: *mut nsIAtom; + pub static nsGkAtoms_onupdatestart: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8onupdateE"] - pub static nsGkAtoms_onupdate: *mut nsIAtom; + pub static nsGkAtoms_onupdate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11onupdateendE"] - pub static nsGkAtoms_onupdateend: *mut nsIAtom; + pub static nsGkAtoms_onupdateend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17onaddsourcebufferE"] - pub static nsGkAtoms_onaddsourcebuffer: *mut nsIAtom; + pub static nsGkAtoms_onaddsourcebuffer: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms20onremovesourcebufferE"] - pub static nsGkAtoms_onremovesourcebuffer: *mut nsIAtom; + pub static nsGkAtoms_onremovesourcebuffer: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5xlinkE"] - pub static nsGkAtoms_xlink: *mut nsIAtom; + pub static nsGkAtoms_xlink: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9xml_spaceE"] - pub static nsGkAtoms_xml_space: *mut nsIAtom; + pub static nsGkAtoms_xml_space: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8xml_langE"] - pub static nsGkAtoms_xml_lang: *mut nsIAtom; + pub static nsGkAtoms_xml_lang: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8xml_baseE"] - pub static nsGkAtoms_xml_base: *mut nsIAtom; + pub static nsGkAtoms_xml_base: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9aria_grabE"] - pub static nsGkAtoms_aria_grab: *mut nsIAtom; + pub static nsGkAtoms_aria_grab: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12aria_channelE"] - pub static nsGkAtoms_aria_channel: *mut nsIAtom; + pub static nsGkAtoms_aria_channel: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11aria_secretE"] - pub static nsGkAtoms_aria_secret: *mut nsIAtom; + pub static nsGkAtoms_aria_secret: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15aria_templateidE"] - pub static nsGkAtoms_aria_templateid: *mut nsIAtom; + pub static nsGkAtoms_aria_templateid: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13aria_datatypeE"] - pub static nsGkAtoms_aria_datatype: *mut nsIAtom; + pub static nsGkAtoms_aria_datatype: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms5localE"] - pub static nsGkAtoms_local: *mut nsIAtom; + pub static nsGkAtoms_local: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16xchannelselectorE"] - pub static nsGkAtoms_xchannelselector: *mut nsIAtom; + pub static nsGkAtoms_xchannelselector: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16ychannelselectorE"] - pub static nsGkAtoms_ychannelselector: *mut nsIAtom; + pub static nsGkAtoms_ychannelselector: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17enable_backgroundE"] - pub static nsGkAtoms_enable_background: *mut nsIAtom; + pub static nsGkAtoms_enable_background: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8calcmodeE"] - pub static nsGkAtoms_calcmode: *mut nsIAtom; + pub static nsGkAtoms_calcmode: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16specularexponentE"] - pub static nsGkAtoms_specularexponent: *mut nsIAtom; + pub static nsGkAtoms_specularexponent: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16specularconstantE"] - pub static nsGkAtoms_specularconstant: *mut nsIAtom; + pub static nsGkAtoms_specularconstant: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17gradienttransformE"] - pub static nsGkAtoms_gradienttransform: *mut nsIAtom; + pub static nsGkAtoms_gradienttransform: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13gradientunitsE"] - pub static nsGkAtoms_gradientunits: *mut nsIAtom; + pub static nsGkAtoms_gradientunits: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16rendering_intentE"] - pub static nsGkAtoms_rendering_intent: *mut nsIAtom; + pub static nsGkAtoms_rendering_intent: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12stddeviationE"] - pub static nsGkAtoms_stddeviation: *mut nsIAtom; + pub static nsGkAtoms_stddeviation: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13basefrequencyE"] - pub static nsGkAtoms_basefrequency: *mut nsIAtom; + pub static nsGkAtoms_basefrequency: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11baseprofileE"] - pub static nsGkAtoms_baseprofile: *mut nsIAtom; + pub static nsGkAtoms_baseprofile: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11baseProfileE"] - pub static nsGkAtoms_baseProfile: *mut nsIAtom; + pub static nsGkAtoms_baseProfile: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8edgemodeE"] - pub static nsGkAtoms_edgemode: *mut nsIAtom; + pub static nsGkAtoms_edgemode: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11repeatcountE"] - pub static nsGkAtoms_repeatcount: *mut nsIAtom; + pub static nsGkAtoms_repeatcount: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9repeatdurE"] - pub static nsGkAtoms_repeatdur: *mut nsIAtom; + pub static nsGkAtoms_repeatdur: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12spreadmethodE"] - pub static nsGkAtoms_spreadmethod: *mut nsIAtom; + pub static nsGkAtoms_spreadmethod: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15diffuseconstantE"] - pub static nsGkAtoms_diffuseconstant: *mut nsIAtom; + pub static nsGkAtoms_diffuseconstant: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12surfacescaleE"] - pub static nsGkAtoms_surfacescale: *mut nsIAtom; + pub static nsGkAtoms_surfacescale: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12lengthadjustE"] - pub static nsGkAtoms_lengthadjust: *mut nsIAtom; + pub static nsGkAtoms_lengthadjust: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6originE"] - pub static nsGkAtoms_origin: *mut nsIAtom; + pub static nsGkAtoms_origin: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7targetxE"] - pub static nsGkAtoms_targetx: *mut nsIAtom; + pub static nsGkAtoms_targetx: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7targetyE"] - pub static nsGkAtoms_targety: *mut nsIAtom; + pub static nsGkAtoms_targety: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10pathlengthE"] - pub static nsGkAtoms_pathlength: *mut nsIAtom; + pub static nsGkAtoms_pathlength: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13definitionurlE"] - pub static nsGkAtoms_definitionurl: *mut nsIAtom; + pub static nsGkAtoms_definitionurl: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17limitingconeangleE"] - pub static nsGkAtoms_limitingconeangle: *mut nsIAtom; + pub static nsGkAtoms_limitingconeangle: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12markerheightE"] - pub static nsGkAtoms_markerheight: *mut nsIAtom; + pub static nsGkAtoms_markerheight: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11markerwidthE"] - pub static nsGkAtoms_markerwidth: *mut nsIAtom; + pub static nsGkAtoms_markerwidth: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9maskunitsE"] - pub static nsGkAtoms_maskunits: *mut nsIAtom; + pub static nsGkAtoms_maskunits: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11markerunitsE"] - pub static nsGkAtoms_markerunits: *mut nsIAtom; + pub static nsGkAtoms_markerunits: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16maskcontentunitsE"] - pub static nsGkAtoms_maskcontentunits: *mut nsIAtom; + pub static nsGkAtoms_maskcontentunits: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11tablevaluesE"] - pub static nsGkAtoms_tablevalues: *mut nsIAtom; + pub static nsGkAtoms_tablevalues: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14primitiveunitsE"] - pub static nsGkAtoms_primitiveunits: *mut nsIAtom; + pub static nsGkAtoms_primitiveunits: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10zoomandpanE"] - pub static nsGkAtoms_zoomandpan: *mut nsIAtom; + pub static nsGkAtoms_zoomandpan: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12kernelmatrixE"] - pub static nsGkAtoms_kernelmatrix: *mut nsIAtom; + pub static nsGkAtoms_kernelmatrix: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7kerningE"] - pub static nsGkAtoms_kerning: *mut nsIAtom; + pub static nsGkAtoms_kerning: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16kernelunitlengthE"] - pub static nsGkAtoms_kernelunitlength: *mut nsIAtom; + pub static nsGkAtoms_kernelunitlength: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9pointsatxE"] - pub static nsGkAtoms_pointsatx: *mut nsIAtom; + pub static nsGkAtoms_pointsatx: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9pointsatyE"] - pub static nsGkAtoms_pointsaty: *mut nsIAtom; + pub static nsGkAtoms_pointsaty: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9pointsatzE"] - pub static nsGkAtoms_pointsatz: *mut nsIAtom; + pub static nsGkAtoms_pointsatz: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10xlink_hrefE"] - pub static nsGkAtoms_xlink_href: *mut nsIAtom; + pub static nsGkAtoms_xlink_href: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11xlink_titleE"] - pub static nsGkAtoms_xlink_title: *mut nsIAtom; + pub static nsGkAtoms_xlink_title: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10xlink_roleE"] - pub static nsGkAtoms_xlink_role: *mut nsIAtom; + pub static nsGkAtoms_xlink_role: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13xlink_arcroleE"] - pub static nsGkAtoms_xlink_arcrole: *mut nsIAtom; + pub static nsGkAtoms_xlink_arcrole: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7arcroleE"] - pub static nsGkAtoms_arcrole: *mut nsIAtom; + pub static nsGkAtoms_arcrole: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11xmlns_xlinkE"] - pub static nsGkAtoms_xmlns_xlink: *mut nsIAtom; + pub static nsGkAtoms_xmlns_xlink: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10xlink_typeE"] - pub static nsGkAtoms_xlink_type: *mut nsIAtom; + pub static nsGkAtoms_xlink_type: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10xlink_showE"] - pub static nsGkAtoms_xlink_show: *mut nsIAtom; + pub static nsGkAtoms_xlink_show: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13xlink_actuateE"] - pub static nsGkAtoms_xlink_actuate: *mut nsIAtom; + pub static nsGkAtoms_xlink_actuate: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms15color_renderingE"] - pub static nsGkAtoms_color_rendering: *mut nsIAtom; + pub static nsGkAtoms_color_rendering: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10numoctavesE"] - pub static nsGkAtoms_numoctaves: *mut nsIAtom; + pub static nsGkAtoms_numoctaves: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12onmousewheelE"] - pub static nsGkAtoms_onmousewheel: *mut nsIAtom; + pub static nsGkAtoms_onmousewheel: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13clippathunitsE"] - pub static nsGkAtoms_clippathunits: *mut nsIAtom; + pub static nsGkAtoms_clippathunits: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms26glyph_orientation_verticalE"] - pub static nsGkAtoms_glyph_orientation_vertical: *mut nsIAtom; + pub static nsGkAtoms_glyph_orientation_vertical: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms28glyph_orientation_horizontalE"] - pub static nsGkAtoms_glyph_orientation_horizontal: *mut nsIAtom; + pub static nsGkAtoms_glyph_orientation_horizontal: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8glyphrefE"] - pub static nsGkAtoms_glyphref: *mut nsIAtom; + pub static nsGkAtoms_glyphref: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms9keypointsE"] - pub static nsGkAtoms_keypoints: *mut nsIAtom; + pub static nsGkAtoms_keypoints: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13attributenameE"] - pub static nsGkAtoms_attributename: *mut nsIAtom; + pub static nsGkAtoms_attributename: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13attributetypeE"] - pub static nsGkAtoms_attributetype: *mut nsIAtom; + pub static nsGkAtoms_attributetype: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11startoffsetE"] - pub static nsGkAtoms_startoffset: *mut nsIAtom; + pub static nsGkAtoms_startoffset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10keysplinesE"] - pub static nsGkAtoms_keysplines: *mut nsIAtom; + pub static nsGkAtoms_keysplines: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13preservealphaE"] - pub static nsGkAtoms_preservealpha: *mut nsIAtom; + pub static nsGkAtoms_preservealpha: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19preserveaspectratioE"] - pub static nsGkAtoms_preserveaspectratio: *mut nsIAtom; + pub static nsGkAtoms_preserveaspectratio: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7alttextE"] - pub static nsGkAtoms_alttext: *mut nsIAtom; + pub static nsGkAtoms_alttext: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11filterunitsE"] - pub static nsGkAtoms_filterunits: *mut nsIAtom; + pub static nsGkAtoms_filterunits: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8keytimesE"] - pub static nsGkAtoms_keytimes: *mut nsIAtom; + pub static nsGkAtoms_keytimes: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16patterntransformE"] - pub static nsGkAtoms_patterntransform: *mut nsIAtom; + pub static nsGkAtoms_patterntransform: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12patternunitsE"] - pub static nsGkAtoms_patternunits: *mut nsIAtom; + pub static nsGkAtoms_patternunits: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19patterncontentunitsE"] - pub static nsGkAtoms_patterncontentunits: *mut nsIAtom; + pub static nsGkAtoms_patterncontentunits: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11stitchtilesE"] - pub static nsGkAtoms_stitchtiles: *mut nsIAtom; + pub static nsGkAtoms_stitchtiles: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14systemlanguageE"] - pub static nsGkAtoms_systemlanguage: *mut nsIAtom; + pub static nsGkAtoms_systemlanguage: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10textlengthE"] - pub static nsGkAtoms_textlength: *mut nsIAtom; + pub static nsGkAtoms_textlength: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16requiredfeaturesE"] - pub static nsGkAtoms_requiredfeatures: *mut nsIAtom; + pub static nsGkAtoms_requiredfeatures: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18requiredextensionsE"] - pub static nsGkAtoms_requiredextensions: *mut nsIAtom; + pub static nsGkAtoms_requiredextensions: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms10viewtargetE"] - pub static nsGkAtoms_viewtarget: *mut nsIAtom; + pub static nsGkAtoms_viewtarget: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7viewboxE"] - pub static nsGkAtoms_viewbox: *mut nsIAtom; + pub static nsGkAtoms_viewbox: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4refxE"] - pub static nsGkAtoms_refx: *mut nsIAtom; + pub static nsGkAtoms_refx: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms4refyE"] - pub static nsGkAtoms_refy: *mut nsIAtom; + pub static nsGkAtoms_refy: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7fefuncaE"] - pub static nsGkAtoms_fefunca: *mut nsIAtom; + pub static nsGkAtoms_fefunca: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7fefuncbE"] - pub static nsGkAtoms_fefuncb: *mut nsIAtom; + pub static nsGkAtoms_fefuncb: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7feblendE"] - pub static nsGkAtoms_feblend: *mut nsIAtom; + pub static nsGkAtoms_feblend: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7fefloodE"] - pub static nsGkAtoms_feflood: *mut nsIAtom; + pub static nsGkAtoms_feflood: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12feturbulenceE"] - pub static nsGkAtoms_feturbulence: *mut nsIAtom; + pub static nsGkAtoms_feturbulence: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11femergenodeE"] - pub static nsGkAtoms_femergenode: *mut nsIAtom; + pub static nsGkAtoms_femergenode: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7feimageE"] - pub static nsGkAtoms_feimage: *mut nsIAtom; + pub static nsGkAtoms_feimage: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7femergeE"] - pub static nsGkAtoms_femerge: *mut nsIAtom; + pub static nsGkAtoms_femerge: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms6fetileE"] - pub static nsGkAtoms_fetile: *mut nsIAtom; + pub static nsGkAtoms_fetile: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11fecompositeE"] - pub static nsGkAtoms_fecomposite: *mut nsIAtom; + pub static nsGkAtoms_fecomposite: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11altglyphdefE"] - pub static nsGkAtoms_altglyphdef: *mut nsIAtom; + pub static nsGkAtoms_altglyphdef: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11altGlyphDefE"] - pub static nsGkAtoms_altGlyphDef: *mut nsIAtom; + pub static nsGkAtoms_altGlyphDef: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7fefuncgE"] - pub static nsGkAtoms_fefuncg: *mut nsIAtom; + pub static nsGkAtoms_fefuncg: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17fediffuselightingE"] - pub static nsGkAtoms_fediffuselighting: *mut nsIAtom; + pub static nsGkAtoms_fediffuselighting: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms18fespecularlightingE"] - pub static nsGkAtoms_fespecularlighting: *mut nsIAtom; + pub static nsGkAtoms_fespecularlighting: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8altglyphE"] - pub static nsGkAtoms_altglyph: *mut nsIAtom; + pub static nsGkAtoms_altglyph: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8altGlyphE"] - pub static nsGkAtoms_altGlyph: *mut nsIAtom; + pub static nsGkAtoms_altGlyph: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8clippathE"] - pub static nsGkAtoms_clippath: *mut nsIAtom; + pub static nsGkAtoms_clippath: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8textpathE"] - pub static nsGkAtoms_textpath: *mut nsIAtom; + pub static nsGkAtoms_textpath: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12altglyphitemE"] - pub static nsGkAtoms_altglyphitem: *mut nsIAtom; + pub static nsGkAtoms_altglyphitem: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12altGlyphItemE"] - pub static nsGkAtoms_altGlyphItem: *mut nsIAtom; + pub static nsGkAtoms_altGlyphItem: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16animatetransformE"] - pub static nsGkAtoms_animatetransform: *mut nsIAtom; + pub static nsGkAtoms_animatetransform: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13animatemotionE"] - pub static nsGkAtoms_animatemotion: *mut nsIAtom; + pub static nsGkAtoms_animatemotion: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms17fedisplacementmapE"] - pub static nsGkAtoms_fedisplacementmap: *mut nsIAtom; + pub static nsGkAtoms_fedisplacementmap: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12animatecolorE"] - pub static nsGkAtoms_animatecolor: *mut nsIAtom; + pub static nsGkAtoms_animatecolor: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms7fefuncrE"] - pub static nsGkAtoms_fefuncr: *mut nsIAtom; + pub static nsGkAtoms_fefuncr: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms19fecomponenttransferE"] - pub static nsGkAtoms_fecomponenttransfer: *mut nsIAtom; + pub static nsGkAtoms_fecomponenttransfer: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14fegaussianblurE"] - pub static nsGkAtoms_fegaussianblur: *mut nsIAtom; + pub static nsGkAtoms_fegaussianblur: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13foreignobjectE"] - pub static nsGkAtoms_foreignobject: *mut nsIAtom; + pub static nsGkAtoms_foreignobject: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms8feoffsetE"] - pub static nsGkAtoms_feoffset: *mut nsIAtom; + pub static nsGkAtoms_feoffset: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms11fespotlightE"] - pub static nsGkAtoms_fespotlight: *mut nsIAtom; + pub static nsGkAtoms_fespotlight: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12fepointlightE"] - pub static nsGkAtoms_fepointlight: *mut nsIAtom; + pub static nsGkAtoms_fepointlight: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14fedistantlightE"] - pub static nsGkAtoms_fedistantlight: *mut nsIAtom; + pub static nsGkAtoms_fedistantlight: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14lineargradientE"] - pub static nsGkAtoms_lineargradient: *mut nsIAtom; + pub static nsGkAtoms_lineargradient: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms14radialgradientE"] - pub static nsGkAtoms_radialgradient: *mut nsIAtom; + pub static nsGkAtoms_radialgradient: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12fedropshadowE"] - pub static nsGkAtoms_fedropshadow: *mut nsIAtom; + pub static nsGkAtoms_fedropshadow: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms13fecolormatrixE"] - pub static nsGkAtoms_fecolormatrix: *mut nsIAtom; + pub static nsGkAtoms_fecolormatrix: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms16feconvolvematrixE"] - pub static nsGkAtoms_feconvolvematrix: *mut nsIAtom; + pub static nsGkAtoms_feconvolvematrix: *mut nsAtom; #[link_name = "_ZN9nsGkAtoms12femorphologyE"] - pub static nsGkAtoms_femorphology: *mut nsIAtom; + pub static nsGkAtoms_femorphology: *mut nsAtom; #[link_name = "_ZN19nsCSSPseudoElements5afterE"] pub static nsCSSPseudoElements_after: *mut nsICSSPseudoElement; #[link_name = "_ZN19nsCSSPseudoElements6beforeE"] @@ -5189,5006 +5189,5006 @@ cfg_if! { } } else if #[cfg(target_pointer_width = "64")] { extern { - #[link_name = "?_empty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__empty: *mut nsIAtom; - #[link_name = "?moz@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_moz: *mut nsIAtom; - #[link_name = "?mozframetype@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozframetype: *mut nsIAtom; - #[link_name = "?_moz_abspos@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_abspos: *mut nsIAtom; - #[link_name = "?_moz_activated@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_activated: *mut nsIAtom; - #[link_name = "?_moz_anonclass@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_anonclass: *mut nsIAtom; - #[link_name = "?_moz_resizing@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_resizing: *mut nsIAtom; - #[link_name = "?mozallowfullscreen@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozallowfullscreen: *mut nsIAtom; - #[link_name = "?moztype@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_moztype: *mut nsIAtom; - #[link_name = "?mozdirty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozdirty: *mut nsIAtom; - #[link_name = "?mozdisallowselectionprint@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozdisallowselectionprint: *mut nsIAtom; - #[link_name = "?mozdonotsend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozdonotsend: *mut nsIAtom; - #[link_name = "?mozeditorbogusnode@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozeditorbogusnode: *mut nsIAtom; - #[link_name = "?mozgeneratedcontentbefore@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozgeneratedcontentbefore: *mut nsIAtom; - #[link_name = "?mozgeneratedcontentafter@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozgeneratedcontentafter: *mut nsIAtom; - #[link_name = "?mozgeneratedcontentimage@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozgeneratedcontentimage: *mut nsIAtom; - #[link_name = "?mozquote@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozquote: *mut nsIAtom; - #[link_name = "?mozsignature@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozsignature: *mut nsIAtom; - #[link_name = "?_moz_is_glyph@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_is_glyph: *mut nsIAtom; - #[link_name = "?_moz_original_size@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_original_size: *mut nsIAtom; - #[link_name = "?_moz_target@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_target: *mut nsIAtom; - #[link_name = "?menuactive@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_menuactive: *mut nsIAtom; - #[link_name = "?_poundDefault@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__poundDefault: *mut nsIAtom; - #[link_name = "?_asterisk@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__asterisk: *mut nsIAtom; - #[link_name = "?a@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_a: *mut nsIAtom; - #[link_name = "?abbr@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_abbr: *mut nsIAtom; - #[link_name = "?abort@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_abort: *mut nsIAtom; - #[link_name = "?above@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_above: *mut nsIAtom; - #[link_name = "?acceltext@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_acceltext: *mut nsIAtom; - #[link_name = "?accept@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_accept: *mut nsIAtom; - #[link_name = "?acceptcharset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_acceptcharset: *mut nsIAtom; - #[link_name = "?accesskey@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_accesskey: *mut nsIAtom; - #[link_name = "?acronym@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_acronym: *mut nsIAtom; - #[link_name = "?action@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_action: *mut nsIAtom; - #[link_name = "?active@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_active: *mut nsIAtom; - #[link_name = "?activetitlebarcolor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_activetitlebarcolor: *mut nsIAtom; - #[link_name = "?activateontab@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_activateontab: *mut nsIAtom; - #[link_name = "?actuate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_actuate: *mut nsIAtom; - #[link_name = "?address@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_address: *mut nsIAtom; - #[link_name = "?after@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_after: *mut nsIAtom; - #[link_name = "?after_end@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_after_end: *mut nsIAtom; - #[link_name = "?after_start@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_after_start: *mut nsIAtom; - #[link_name = "?align@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_align: *mut nsIAtom; - #[link_name = "?alink@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_alink: *mut nsIAtom; - #[link_name = "?all@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_all: *mut nsIAtom; - #[link_name = "?allowdirs@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_allowdirs: *mut nsIAtom; - #[link_name = "?allowevents@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_allowevents: *mut nsIAtom; - #[link_name = "?allownegativeassertions@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_allownegativeassertions: *mut nsIAtom; - #[link_name = "?allowforms@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_allowforms: *mut nsIAtom; - #[link_name = "?allowfullscreen@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_allowfullscreen: *mut nsIAtom; - #[link_name = "?allowmodals@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_allowmodals: *mut nsIAtom; - #[link_name = "?alloworientationlock@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_alloworientationlock: *mut nsIAtom; - #[link_name = "?allowpaymentrequest@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_allowpaymentrequest: *mut nsIAtom; - #[link_name = "?allowpointerlock@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_allowpointerlock: *mut nsIAtom; - #[link_name = "?allowpopupstoescapesandbox@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_allowpopupstoescapesandbox: *mut nsIAtom; - #[link_name = "?allowpopups@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_allowpopups: *mut nsIAtom; - #[link_name = "?allowpresentation@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_allowpresentation: *mut nsIAtom; - #[link_name = "?allowsameorigin@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_allowsameorigin: *mut nsIAtom; - #[link_name = "?allowscripts@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_allowscripts: *mut nsIAtom; - #[link_name = "?allowtopnavigation@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_allowtopnavigation: *mut nsIAtom; - #[link_name = "?allowuntrusted@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_allowuntrusted: *mut nsIAtom; - #[link_name = "?alt@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_alt: *mut nsIAtom; - #[link_name = "?alternate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_alternate: *mut nsIAtom; - #[link_name = "?always@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_always: *mut nsIAtom; - #[link_name = "?ancestor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ancestor: *mut nsIAtom; - #[link_name = "?ancestorOrSelf@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ancestorOrSelf: *mut nsIAtom; - #[link_name = "?anchor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_anchor: *mut nsIAtom; - #[link_name = "?_and@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__and: *mut nsIAtom; - #[link_name = "?animations@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_animations: *mut nsIAtom; - #[link_name = "?anonid@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_anonid: *mut nsIAtom; - #[link_name = "?anonlocation@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_anonlocation: *mut nsIAtom; - #[link_name = "?any@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_any: *mut nsIAtom; - #[link_name = "?applet@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_applet: *mut nsIAtom; - #[link_name = "?applyImports@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_applyImports: *mut nsIAtom; - #[link_name = "?applyTemplates@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_applyTemplates: *mut nsIAtom; - #[link_name = "?archive@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_archive: *mut nsIAtom; - #[link_name = "?area@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_area: *mut nsIAtom; - #[link_name = "?aria_activedescendant@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_activedescendant: *mut nsIAtom; - #[link_name = "?aria_atomic@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_atomic: *mut nsIAtom; - #[link_name = "?aria_autocomplete@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_autocomplete: *mut nsIAtom; - #[link_name = "?aria_busy@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_busy: *mut nsIAtom; - #[link_name = "?aria_checked@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_checked: *mut nsIAtom; - #[link_name = "?aria_controls@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_controls: *mut nsIAtom; - #[link_name = "?aria_current@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_current: *mut nsIAtom; - #[link_name = "?aria_describedby@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_describedby: *mut nsIAtom; - #[link_name = "?aria_disabled@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_disabled: *mut nsIAtom; - #[link_name = "?aria_dropeffect@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_dropeffect: *mut nsIAtom; - #[link_name = "?aria_expanded@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_expanded: *mut nsIAtom; - #[link_name = "?aria_flowto@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_flowto: *mut nsIAtom; - #[link_name = "?aria_haspopup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_haspopup: *mut nsIAtom; - #[link_name = "?aria_hidden@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_hidden: *mut nsIAtom; - #[link_name = "?aria_invalid@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_invalid: *mut nsIAtom; - #[link_name = "?aria_labelledby@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_labelledby: *mut nsIAtom; - #[link_name = "?aria_level@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_level: *mut nsIAtom; - #[link_name = "?aria_live@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_live: *mut nsIAtom; - #[link_name = "?aria_multiline@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_multiline: *mut nsIAtom; - #[link_name = "?aria_multiselectable@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_multiselectable: *mut nsIAtom; - #[link_name = "?aria_owns@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_owns: *mut nsIAtom; - #[link_name = "?aria_posinset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_posinset: *mut nsIAtom; - #[link_name = "?aria_pressed@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_pressed: *mut nsIAtom; - #[link_name = "?aria_readonly@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_readonly: *mut nsIAtom; - #[link_name = "?aria_relevant@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_relevant: *mut nsIAtom; - #[link_name = "?aria_required@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_required: *mut nsIAtom; - #[link_name = "?aria_selected@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_selected: *mut nsIAtom; - #[link_name = "?aria_setsize@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_setsize: *mut nsIAtom; - #[link_name = "?aria_sort@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_sort: *mut nsIAtom; - #[link_name = "?aria_valuemax@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_valuemax: *mut nsIAtom; - #[link_name = "?aria_valuemin@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_valuemin: *mut nsIAtom; - #[link_name = "?aria_valuenow@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_valuenow: *mut nsIAtom; - #[link_name = "?arrow@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_arrow: *mut nsIAtom; - #[link_name = "?article@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_article: *mut nsIAtom; - #[link_name = "?as@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_as: *mut nsIAtom; - #[link_name = "?ascending@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ascending: *mut nsIAtom; - #[link_name = "?aside@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aside: *mut nsIAtom; - #[link_name = "?aspectRatio@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aspectRatio: *mut nsIAtom; - #[link_name = "?assign@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_assign: *mut nsIAtom; - #[link_name = "?async@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_async: *mut nsIAtom; - #[link_name = "?attribute@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_attribute: *mut nsIAtom; - #[link_name = "?attributes@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_attributes: *mut nsIAtom; - #[link_name = "?attributeSet@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_attributeSet: *mut nsIAtom; - #[link_name = "?aural@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aural: *mut nsIAtom; - #[link_name = "?_auto@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__auto: *mut nsIAtom; - #[link_name = "?autocheck@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_autocheck: *mut nsIAtom; - #[link_name = "?autocomplete@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_autocomplete: *mut nsIAtom; - #[link_name = "?autofocus@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_autofocus: *mut nsIAtom; - #[link_name = "?autoplay@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_autoplay: *mut nsIAtom; - #[link_name = "?autorepeatbutton@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_autorepeatbutton: *mut nsIAtom; - #[link_name = "?axis@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_axis: *mut nsIAtom; - #[link_name = "?b@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_b: *mut nsIAtom; - #[link_name = "?background@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_background: *mut nsIAtom; - #[link_name = "?base@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_base: *mut nsIAtom; - #[link_name = "?basefont@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_basefont: *mut nsIAtom; - #[link_name = "?baseline@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_baseline: *mut nsIAtom; - #[link_name = "?bdi@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_bdi: *mut nsIAtom; - #[link_name = "?bdo@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_bdo: *mut nsIAtom; - #[link_name = "?before@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_before: *mut nsIAtom; - #[link_name = "?before_end@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_before_end: *mut nsIAtom; - #[link_name = "?before_start@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_before_start: *mut nsIAtom; - #[link_name = "?below@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_below: *mut nsIAtom; - #[link_name = "?bgcolor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_bgcolor: *mut nsIAtom; - #[link_name = "?bgsound@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_bgsound: *mut nsIAtom; - #[link_name = "?big@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_big: *mut nsIAtom; - #[link_name = "?binding@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_binding: *mut nsIAtom; - #[link_name = "?bindings@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_bindings: *mut nsIAtom; - #[link_name = "?bindToUntrustedContent@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_bindToUntrustedContent: *mut nsIAtom; - #[link_name = "?blankrow@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_blankrow: *mut nsIAtom; - #[link_name = "?block@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_block: *mut nsIAtom; - #[link_name = "?blockquote@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_blockquote: *mut nsIAtom; - #[link_name = "?blur@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_blur: *mut nsIAtom; - #[link_name = "?body@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_body: *mut nsIAtom; - #[link_name = "?boolean@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_boolean: *mut nsIAtom; - #[link_name = "?border@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_border: *mut nsIAtom; - #[link_name = "?bordercolor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_bordercolor: *mut nsIAtom; - #[link_name = "?both@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_both: *mut nsIAtom; - #[link_name = "?bottom@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_bottom: *mut nsIAtom; - #[link_name = "?bottomend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_bottomend: *mut nsIAtom; - #[link_name = "?bottomstart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_bottomstart: *mut nsIAtom; - #[link_name = "?bottomleft@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_bottomleft: *mut nsIAtom; - #[link_name = "?bottommargin@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_bottommargin: *mut nsIAtom; - #[link_name = "?bottompadding@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_bottompadding: *mut nsIAtom; - #[link_name = "?bottomright@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_bottomright: *mut nsIAtom; - #[link_name = "?box@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_box: *mut nsIAtom; - #[link_name = "?br@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_br: *mut nsIAtom; - #[link_name = "?braille@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_braille: *mut nsIAtom; - #[link_name = "?broadcast@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_broadcast: *mut nsIAtom; - #[link_name = "?broadcaster@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_broadcaster: *mut nsIAtom; - #[link_name = "?broadcasterset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_broadcasterset: *mut nsIAtom; - #[link_name = "?browser@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_browser: *mut nsIAtom; - #[link_name = "?mozbrowser@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozbrowser: *mut nsIAtom; - #[link_name = "?bulletinboard@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_bulletinboard: *mut nsIAtom; - #[link_name = "?button@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_button: *mut nsIAtom; - #[link_name = "?brighttitlebarforeground@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_brighttitlebarforeground: *mut nsIAtom; - #[link_name = "?callTemplate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_callTemplate: *mut nsIAtom; - #[link_name = "?cancel@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cancel: *mut nsIAtom; - #[link_name = "?canvas@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_canvas: *mut nsIAtom; - #[link_name = "?caption@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_caption: *mut nsIAtom; - #[link_name = "?capture@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_capture: *mut nsIAtom; - #[link_name = "?caseOrder@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_caseOrder: *mut nsIAtom; - #[link_name = "?cdataSectionElements@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cdataSectionElements: *mut nsIAtom; - #[link_name = "?ceiling@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ceiling: *mut nsIAtom; - #[link_name = "?cell@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cell: *mut nsIAtom; - #[link_name = "?cellpadding@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cellpadding: *mut nsIAtom; - #[link_name = "?cellspacing@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cellspacing: *mut nsIAtom; - #[link_name = "?center@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_center: *mut nsIAtom; - #[link_name = "?ch@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ch: *mut nsIAtom; - #[link_name = "?change@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_change: *mut nsIAtom; - #[link_name = "?_char@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__char: *mut nsIAtom; - #[link_name = "?characterData@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_characterData: *mut nsIAtom; - #[link_name = "?charcode@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_charcode: *mut nsIAtom; - #[link_name = "?charoff@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_charoff: *mut nsIAtom; - #[link_name = "?charset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_charset: *mut nsIAtom; - #[link_name = "?checkbox@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_checkbox: *mut nsIAtom; - #[link_name = "?checked@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_checked: *mut nsIAtom; - #[link_name = "?child@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_child: *mut nsIAtom; - #[link_name = "?children@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_children: *mut nsIAtom; - #[link_name = "?childList@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_childList: *mut nsIAtom; - #[link_name = "?choose@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_choose: *mut nsIAtom; - #[link_name = "?chromemargin@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_chromemargin: *mut nsIAtom; - #[link_name = "?chromeOnlyContent@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_chromeOnlyContent: *mut nsIAtom; - #[link_name = "?exposeToUntrustedContent@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_exposeToUntrustedContent: *mut nsIAtom; - #[link_name = "?circ@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_circ: *mut nsIAtom; - #[link_name = "?circle@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_circle: *mut nsIAtom; - #[link_name = "?cite@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cite: *mut nsIAtom; - #[link_name = "?cjkDecimal@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cjkDecimal: *mut nsIAtom; - #[link_name = "?_class@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__class: *mut nsIAtom; - #[link_name = "?classid@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_classid: *mut nsIAtom; - #[link_name = "?clear@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_clear: *mut nsIAtom; - #[link_name = "?click@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_click: *mut nsIAtom; - #[link_name = "?clickcount@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_clickcount: *mut nsIAtom; - #[link_name = "?clickthrough@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_clickthrough: *mut nsIAtom; - #[link_name = "?movetoclick@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_movetoclick: *mut nsIAtom; - #[link_name = "?clip@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_clip: *mut nsIAtom; - #[link_name = "?close@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_close: *mut nsIAtom; - #[link_name = "?closed@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_closed: *mut nsIAtom; - #[link_name = "?closemenu@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_closemenu: *mut nsIAtom; - #[link_name = "?coalesceduplicatearcs@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_coalesceduplicatearcs: *mut nsIAtom; - #[link_name = "?code@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_code: *mut nsIAtom; - #[link_name = "?codebase@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_codebase: *mut nsIAtom; - #[link_name = "?codetype@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_codetype: *mut nsIAtom; - #[link_name = "?col@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_col: *mut nsIAtom; - #[link_name = "?colgroup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_colgroup: *mut nsIAtom; - #[link_name = "?collapse@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_collapse: *mut nsIAtom; - #[link_name = "?collapsed@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_collapsed: *mut nsIAtom; - #[link_name = "?color@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_color: *mut nsIAtom; - #[link_name = "?colorIndex@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_colorIndex: *mut nsIAtom; - #[link_name = "?cols@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cols: *mut nsIAtom; - #[link_name = "?colspan@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_colspan: *mut nsIAtom; - #[link_name = "?column@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_column: *mut nsIAtom; - #[link_name = "?columns@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_columns: *mut nsIAtom; - #[link_name = "?combobox@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_combobox: *mut nsIAtom; - #[link_name = "?command@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_command: *mut nsIAtom; - #[link_name = "?commands@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_commands: *mut nsIAtom; - #[link_name = "?commandset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_commandset: *mut nsIAtom; - #[link_name = "?commandupdate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_commandupdate: *mut nsIAtom; - #[link_name = "?commandupdater@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_commandupdater: *mut nsIAtom; - #[link_name = "?comment@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_comment: *mut nsIAtom; - #[link_name = "?compact@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_compact: *mut nsIAtom; - #[link_name = "?concat@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_concat: *mut nsIAtom; - #[link_name = "?conditions@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_conditions: *mut nsIAtom; - #[link_name = "?constructor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_constructor: *mut nsIAtom; - #[link_name = "?consumeoutsideclicks@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_consumeoutsideclicks: *mut nsIAtom; - #[link_name = "?container@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_container: *mut nsIAtom; - #[link_name = "?containment@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_containment: *mut nsIAtom; - #[link_name = "?contains@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_contains: *mut nsIAtom; - #[link_name = "?content@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_content: *mut nsIAtom; - #[link_name = "?contenteditable@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_contenteditable: *mut nsIAtom; - #[link_name = "?headerContentDisposition@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_headerContentDisposition: *mut nsIAtom; - #[link_name = "?headerContentLanguage@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_headerContentLanguage: *mut nsIAtom; - #[link_name = "?contentLocation@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_contentLocation: *mut nsIAtom; - #[link_name = "?headerContentScriptType@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_headerContentScriptType: *mut nsIAtom; - #[link_name = "?headerContentStyleType@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_headerContentStyleType: *mut nsIAtom; - #[link_name = "?headerContentType@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_headerContentType: *mut nsIAtom; - #[link_name = "?consumeanchor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_consumeanchor: *mut nsIAtom; - #[link_name = "?context@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_context: *mut nsIAtom; - #[link_name = "?contextmenu@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_contextmenu: *mut nsIAtom; - #[link_name = "?control@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_control: *mut nsIAtom; - #[link_name = "?controls@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_controls: *mut nsIAtom; - #[link_name = "?coords@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_coords: *mut nsIAtom; - #[link_name = "?copy@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_copy: *mut nsIAtom; - #[link_name = "?copyOf@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_copyOf: *mut nsIAtom; - #[link_name = "?count@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_count: *mut nsIAtom; - #[link_name = "?crop@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_crop: *mut nsIAtom; - #[link_name = "?crossorigin@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_crossorigin: *mut nsIAtom; - #[link_name = "?curpos@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_curpos: *mut nsIAtom; - #[link_name = "?current@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_current: *mut nsIAtom; - #[link_name = "?cutoutregion@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cutoutregion: *mut nsIAtom; - #[link_name = "?cycler@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cycler: *mut nsIAtom; - #[link_name = "?data@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_data: *mut nsIAtom; - #[link_name = "?datalist@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_datalist: *mut nsIAtom; - #[link_name = "?dataType@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dataType: *mut nsIAtom; - #[link_name = "?dateTime@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dateTime: *mut nsIAtom; - #[link_name = "?datasources@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_datasources: *mut nsIAtom; - #[link_name = "?datetime@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_datetime: *mut nsIAtom; - #[link_name = "?datetimebox@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_datetimebox: *mut nsIAtom; - #[link_name = "?dblclick@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dblclick: *mut nsIAtom; - #[link_name = "?dd@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dd: *mut nsIAtom; - #[link_name = "?debug@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_debug: *mut nsIAtom; - #[link_name = "?decimal@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_decimal: *mut nsIAtom; - #[link_name = "?decimalFormat@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_decimalFormat: *mut nsIAtom; - #[link_name = "?decimalSeparator@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_decimalSeparator: *mut nsIAtom; - #[link_name = "?deck@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_deck: *mut nsIAtom; - #[link_name = "?declare@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_declare: *mut nsIAtom; - #[link_name = "?decoderDoctor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_decoderDoctor: *mut nsIAtom; - #[link_name = "?decrement@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_decrement: *mut nsIAtom; - #[link_name = "?_default@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__default: *mut nsIAtom; - #[link_name = "?headerDefaultStyle@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_headerDefaultStyle: *mut nsIAtom; - #[link_name = "?defaultAction@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_defaultAction: *mut nsIAtom; - #[link_name = "?defaultchecked@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_defaultchecked: *mut nsIAtom; - #[link_name = "?defaultLabel@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_defaultLabel: *mut nsIAtom; - #[link_name = "?defaultselected@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_defaultselected: *mut nsIAtom; - #[link_name = "?defaultvalue@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_defaultvalue: *mut nsIAtom; - #[link_name = "?defaultplaybackrate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_defaultplaybackrate: *mut nsIAtom; - #[link_name = "?defer@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_defer: *mut nsIAtom; - #[link_name = "?del@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_del: *mut nsIAtom; - #[link_name = "?descendant@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_descendant: *mut nsIAtom; - #[link_name = "?descendantOrSelf@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_descendantOrSelf: *mut nsIAtom; - #[link_name = "?descending@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_descending: *mut nsIAtom; - #[link_name = "?description@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_description: *mut nsIAtom; - #[link_name = "?destructor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_destructor: *mut nsIAtom; - #[link_name = "?details@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_details: *mut nsIAtom; - #[link_name = "?deviceAspectRatio@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_deviceAspectRatio: *mut nsIAtom; - #[link_name = "?deviceHeight@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_deviceHeight: *mut nsIAtom; - #[link_name = "?devicePixelRatio@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_devicePixelRatio: *mut nsIAtom; - #[link_name = "?deviceWidth@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_deviceWidth: *mut nsIAtom; - #[link_name = "?dfn@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dfn: *mut nsIAtom; - #[link_name = "?dialog@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dialog: *mut nsIAtom; - #[link_name = "?difference@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_difference: *mut nsIAtom; - #[link_name = "?digit@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_digit: *mut nsIAtom; - #[link_name = "?dir@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dir: *mut nsIAtom; - #[link_name = "?dirAutoSetBy@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dirAutoSetBy: *mut nsIAtom; - #[link_name = "?directionality@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_directionality: *mut nsIAtom; - #[link_name = "?directory@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_directory: *mut nsIAtom; - #[link_name = "?disableOutputEscaping@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_disableOutputEscaping: *mut nsIAtom; - #[link_name = "?disabled@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_disabled: *mut nsIAtom; - #[link_name = "?disableglobalhistory@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_disableglobalhistory: *mut nsIAtom; - #[link_name = "?disablehistory@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_disablehistory: *mut nsIAtom; - #[link_name = "?disablefullscreen@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_disablefullscreen: *mut nsIAtom; - #[link_name = "?disclosure_closed@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_disclosure_closed: *mut nsIAtom; - #[link_name = "?disclosure_open@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_disclosure_open: *mut nsIAtom; - #[link_name = "?display@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_display: *mut nsIAtom; - #[link_name = "?displayMode@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_displayMode: *mut nsIAtom; - #[link_name = "?distinct@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_distinct: *mut nsIAtom; - #[link_name = "?div@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_div: *mut nsIAtom; - #[link_name = "?dl@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dl: *mut nsIAtom; - #[link_name = "?docAbstract@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docAbstract: *mut nsIAtom; - #[link_name = "?docAcknowledgments@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docAcknowledgments: *mut nsIAtom; - #[link_name = "?docAfterword@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docAfterword: *mut nsIAtom; - #[link_name = "?docAppendix@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docAppendix: *mut nsIAtom; - #[link_name = "?docBacklink@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docBacklink: *mut nsIAtom; - #[link_name = "?docBiblioentry@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docBiblioentry: *mut nsIAtom; - #[link_name = "?docBibliography@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docBibliography: *mut nsIAtom; - #[link_name = "?docBiblioref@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docBiblioref: *mut nsIAtom; - #[link_name = "?docChapter@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docChapter: *mut nsIAtom; - #[link_name = "?docColophon@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docColophon: *mut nsIAtom; - #[link_name = "?docConclusion@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docConclusion: *mut nsIAtom; - #[link_name = "?docCover@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docCover: *mut nsIAtom; - #[link_name = "?docCredit@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docCredit: *mut nsIAtom; - #[link_name = "?docCredits@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docCredits: *mut nsIAtom; - #[link_name = "?docDedication@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docDedication: *mut nsIAtom; - #[link_name = "?docEndnote@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docEndnote: *mut nsIAtom; - #[link_name = "?docEndnotes@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docEndnotes: *mut nsIAtom; - #[link_name = "?docEpigraph@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docEpigraph: *mut nsIAtom; - #[link_name = "?docEpilogue@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docEpilogue: *mut nsIAtom; - #[link_name = "?docErrata@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docErrata: *mut nsIAtom; - #[link_name = "?docExample@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docExample: *mut nsIAtom; - #[link_name = "?docFootnote@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docFootnote: *mut nsIAtom; - #[link_name = "?docForeword@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docForeword: *mut nsIAtom; - #[link_name = "?docGlossary@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docGlossary: *mut nsIAtom; - #[link_name = "?docGlossref@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docGlossref: *mut nsIAtom; - #[link_name = "?docIndex@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docIndex: *mut nsIAtom; - #[link_name = "?docIntroduction@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docIntroduction: *mut nsIAtom; - #[link_name = "?docNoteref@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docNoteref: *mut nsIAtom; - #[link_name = "?docNotice@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docNotice: *mut nsIAtom; - #[link_name = "?docPagebreak@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docPagebreak: *mut nsIAtom; - #[link_name = "?docPagelist@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docPagelist: *mut nsIAtom; - #[link_name = "?docPart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docPart: *mut nsIAtom; - #[link_name = "?docPreface@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docPreface: *mut nsIAtom; - #[link_name = "?docPrologue@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docPrologue: *mut nsIAtom; - #[link_name = "?docPullquote@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docPullquote: *mut nsIAtom; - #[link_name = "?docQna@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docQna: *mut nsIAtom; - #[link_name = "?docSubtitle@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docSubtitle: *mut nsIAtom; - #[link_name = "?docTip@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docTip: *mut nsIAtom; - #[link_name = "?docToc@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_docToc: *mut nsIAtom; - #[link_name = "?doctypePublic@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_doctypePublic: *mut nsIAtom; - #[link_name = "?doctypeSystem@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_doctypeSystem: *mut nsIAtom; - #[link_name = "?document@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_document: *mut nsIAtom; - #[link_name = "?download@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_download: *mut nsIAtom; - #[link_name = "?DOMAttrModified@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_DOMAttrModified: *mut nsIAtom; - #[link_name = "?DOMCharacterDataModified@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_DOMCharacterDataModified: *mut nsIAtom; - #[link_name = "?DOMNodeInserted@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_DOMNodeInserted: *mut nsIAtom; - #[link_name = "?DOMNodeInsertedIntoDocument@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_DOMNodeInsertedIntoDocument: *mut nsIAtom; - #[link_name = "?DOMNodeRemoved@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_DOMNodeRemoved: *mut nsIAtom; - #[link_name = "?DOMNodeRemovedFromDocument@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_DOMNodeRemovedFromDocument: *mut nsIAtom; - #[link_name = "?DOMSubtreeModified@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_DOMSubtreeModified: *mut nsIAtom; - #[link_name = "?double_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_double_: *mut nsIAtom; - #[link_name = "?drag@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_drag: *mut nsIAtom; - #[link_name = "?dragend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dragend: *mut nsIAtom; - #[link_name = "?dragenter@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dragenter: *mut nsIAtom; - #[link_name = "?dragevent@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dragevent: *mut nsIAtom; - #[link_name = "?dragexit@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dragexit: *mut nsIAtom; - #[link_name = "?draggable@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_draggable: *mut nsIAtom; - #[link_name = "?dragging@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dragging: *mut nsIAtom; - #[link_name = "?dragleave@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dragleave: *mut nsIAtom; - #[link_name = "?dragover@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dragover: *mut nsIAtom; - #[link_name = "?dragSession@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dragSession: *mut nsIAtom; - #[link_name = "?dragstart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dragstart: *mut nsIAtom; - #[link_name = "?drawintitlebar@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_drawintitlebar: *mut nsIAtom; - #[link_name = "?drawtitle@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_drawtitle: *mut nsIAtom; - #[link_name = "?drop@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_drop: *mut nsIAtom; - #[link_name = "?dropAfter@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dropAfter: *mut nsIAtom; - #[link_name = "?dropBefore@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dropBefore: *mut nsIAtom; - #[link_name = "?dropOn@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dropOn: *mut nsIAtom; - #[link_name = "?dropMarker@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dropMarker: *mut nsIAtom; - #[link_name = "?dt@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dt: *mut nsIAtom; - #[link_name = "?editable@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_editable: *mut nsIAtom; - #[link_name = "?editing@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_editing: *mut nsIAtom; - #[link_name = "?editor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_editor: *mut nsIAtom; - #[link_name = "?editorDisplayList@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_editorDisplayList: *mut nsIAtom; - #[link_name = "?element@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_element: *mut nsIAtom; - #[link_name = "?elementAvailable@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_elementAvailable: *mut nsIAtom; - #[link_name = "?elements@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_elements: *mut nsIAtom; - #[link_name = "?em@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_em: *mut nsIAtom; - #[link_name = "?embed@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_embed: *mut nsIAtom; - #[link_name = "?embossed@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_embossed: *mut nsIAtom; - #[link_name = "?empty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_empty: *mut nsIAtom; - #[link_name = "?encoding@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_encoding: *mut nsIAtom; - #[link_name = "?enctype@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_enctype: *mut nsIAtom; - #[link_name = "?end@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_end: *mut nsIAtom; - #[link_name = "?endEvent@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_endEvent: *mut nsIAtom; - #[link_name = "?end_after@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_end_after: *mut nsIAtom; - #[link_name = "?end_before@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_end_before: *mut nsIAtom; - #[link_name = "?equalsize@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_equalsize: *mut nsIAtom; - #[link_name = "?error@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_error: *mut nsIAtom; - #[link_name = "?ethiopic_numeric@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ethiopic_numeric: *mut nsIAtom; - #[link_name = "?even@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_even: *mut nsIAtom; - #[link_name = "?event@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_event: *mut nsIAtom; - #[link_name = "?events@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_events: *mut nsIAtom; - #[link_name = "?excludeResultPrefixes@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_excludeResultPrefixes: *mut nsIAtom; - #[link_name = "?excludes@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_excludes: *mut nsIAtom; - #[link_name = "?expr@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_expr: *mut nsIAtom; - #[link_name = "?extends@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_extends: *mut nsIAtom; - #[link_name = "?extensionElementPrefixes@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_extensionElementPrefixes: *mut nsIAtom; - #[link_name = "?face@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_face: *mut nsIAtom; - #[link_name = "?fallback@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fallback: *mut nsIAtom; - #[link_name = "?_false@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__false: *mut nsIAtom; - #[link_name = "?farthest@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_farthest: *mut nsIAtom; - #[link_name = "?field@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_field: *mut nsIAtom; - #[link_name = "?fieldset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fieldset: *mut nsIAtom; - #[link_name = "?file@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_file: *mut nsIAtom; - #[link_name = "?figcaption@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_figcaption: *mut nsIAtom; - #[link_name = "?figure@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_figure: *mut nsIAtom; - #[link_name = "?fixed@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fixed: *mut nsIAtom; - #[link_name = "?flags@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_flags: *mut nsIAtom; - #[link_name = "?flex@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_flex: *mut nsIAtom; - #[link_name = "?flexgroup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_flexgroup: *mut nsIAtom; - #[link_name = "?flip@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_flip: *mut nsIAtom; - #[link_name = "?floating@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_floating: *mut nsIAtom; - #[link_name = "?floor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_floor: *mut nsIAtom; - #[link_name = "?flowlength@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_flowlength: *mut nsIAtom; - #[link_name = "?focus@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_focus: *mut nsIAtom; - #[link_name = "?focused@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_focused: *mut nsIAtom; - #[link_name = "?followanchor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_followanchor: *mut nsIAtom; - #[link_name = "?following@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_following: *mut nsIAtom; - #[link_name = "?followingSibling@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_followingSibling: *mut nsIAtom; - #[link_name = "?font@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_font: *mut nsIAtom; - #[link_name = "?fontWeight@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fontWeight: *mut nsIAtom; - #[link_name = "?fontpicker@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fontpicker: *mut nsIAtom; - #[link_name = "?footer@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_footer: *mut nsIAtom; - #[link_name = "?_for@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__for: *mut nsIAtom; - #[link_name = "?forEach@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_forEach: *mut nsIAtom; - #[link_name = "?forceOwnRefreshDriver@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_forceOwnRefreshDriver: *mut nsIAtom; - #[link_name = "?form@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_form: *mut nsIAtom; - #[link_name = "?formaction@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_formaction: *mut nsIAtom; - #[link_name = "?format@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_format: *mut nsIAtom; - #[link_name = "?formatNumber@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_formatNumber: *mut nsIAtom; - #[link_name = "?formenctype@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_formenctype: *mut nsIAtom; - #[link_name = "?formmethod@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_formmethod: *mut nsIAtom; - #[link_name = "?formnovalidate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_formnovalidate: *mut nsIAtom; - #[link_name = "?formtarget@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_formtarget: *mut nsIAtom; - #[link_name = "?frame@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_frame: *mut nsIAtom; - #[link_name = "?frameborder@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_frameborder: *mut nsIAtom; - #[link_name = "?frameset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_frameset: *mut nsIAtom; - #[link_name = "?from@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_from: *mut nsIAtom; - #[link_name = "?fullscreenchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fullscreenchange: *mut nsIAtom; - #[link_name = "?fullscreenerror@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fullscreenerror: *mut nsIAtom; - #[link_name = "?functionAvailable@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_functionAvailable: *mut nsIAtom; - #[link_name = "?freshProcess@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_freshProcess: *mut nsIAtom; - #[link_name = "?generateId@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_generateId: *mut nsIAtom; - #[link_name = "?getter@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_getter: *mut nsIAtom; - #[link_name = "?glyphchar@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_glyphchar: *mut nsIAtom; - #[link_name = "?glyphid@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_glyphid: *mut nsIAtom; - #[link_name = "?grid@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_grid: *mut nsIAtom; - #[link_name = "?grippy@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_grippy: *mut nsIAtom; - #[link_name = "?group@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_group: *mut nsIAtom; - #[link_name = "?groupingSeparator@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_groupingSeparator: *mut nsIAtom; - #[link_name = "?groupingSize@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_groupingSize: *mut nsIAtom; - #[link_name = "?grow@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_grow: *mut nsIAtom; - #[link_name = "?gutter@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_gutter: *mut nsIAtom; - #[link_name = "?h1@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_h1: *mut nsIAtom; - #[link_name = "?h2@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_h2: *mut nsIAtom; - #[link_name = "?h3@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_h3: *mut nsIAtom; - #[link_name = "?h4@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_h4: *mut nsIAtom; - #[link_name = "?h5@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_h5: *mut nsIAtom; - #[link_name = "?h6@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_h6: *mut nsIAtom; - #[link_name = "?handheld@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_handheld: *mut nsIAtom; - #[link_name = "?handheldFriendly@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_handheldFriendly: *mut nsIAtom; - #[link_name = "?handler@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_handler: *mut nsIAtom; - #[link_name = "?handlers@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_handlers: *mut nsIAtom; - #[link_name = "?HARD@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_HARD: *mut nsIAtom; - #[link_name = "?haspopup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_haspopup: *mut nsIAtom; - #[link_name = "?hasSameNode@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_hasSameNode: *mut nsIAtom; - #[link_name = "?hbox@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_hbox: *mut nsIAtom; - #[link_name = "?head@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_head: *mut nsIAtom; - #[link_name = "?header@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_header: *mut nsIAtom; - #[link_name = "?headers@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_headers: *mut nsIAtom; - #[link_name = "?hebrew@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_hebrew: *mut nsIAtom; - #[link_name = "?height@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_height: *mut nsIAtom; - #[link_name = "?hgroup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_hgroup: *mut nsIAtom; - #[link_name = "?hidden@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_hidden: *mut nsIAtom; - #[link_name = "?hidechrome@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_hidechrome: *mut nsIAtom; - #[link_name = "?hidecolumnpicker@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_hidecolumnpicker: *mut nsIAtom; - #[link_name = "?high@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_high: *mut nsIAtom; - #[link_name = "?highest@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_highest: *mut nsIAtom; - #[link_name = "?horizontal@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_horizontal: *mut nsIAtom; - #[link_name = "?hover@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_hover: *mut nsIAtom; - #[link_name = "?hr@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_hr: *mut nsIAtom; - #[link_name = "?href@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_href: *mut nsIAtom; - #[link_name = "?hreflang@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_hreflang: *mut nsIAtom; - #[link_name = "?hspace@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_hspace: *mut nsIAtom; - #[link_name = "?html@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_html: *mut nsIAtom; - #[link_name = "?httpEquiv@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_httpEquiv: *mut nsIAtom; - #[link_name = "?i@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_i: *mut nsIAtom; - #[link_name = "?icon@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_icon: *mut nsIAtom; - #[link_name = "?id@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_id: *mut nsIAtom; - #[link_name = "?_if@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__if: *mut nsIAtom; - #[link_name = "?iframe@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_iframe: *mut nsIAtom; - #[link_name = "?ignorecase@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ignorecase: *mut nsIAtom; - #[link_name = "?ignorekeys@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ignorekeys: *mut nsIAtom; - #[link_name = "?ignoreuserfocus@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ignoreuserfocus: *mut nsIAtom; - #[link_name = "?ilayer@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ilayer: *mut nsIAtom; - #[link_name = "?image@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_image: *mut nsIAtom; - #[link_name = "?imageClickedPoint@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_imageClickedPoint: *mut nsIAtom; - #[link_name = "?img@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_img: *mut nsIAtom; - #[link_name = "?implementation@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_implementation: *mut nsIAtom; - #[link_name = "?implements@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_implements: *mut nsIAtom; - #[link_name = "?import@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_import: *mut nsIAtom; - #[link_name = "?inactivetitlebarcolor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_inactivetitlebarcolor: *mut nsIAtom; - #[link_name = "?include@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_include: *mut nsIAtom; - #[link_name = "?includes@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_includes: *mut nsIAtom; - #[link_name = "?increment@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_increment: *mut nsIAtom; - #[link_name = "?indent@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_indent: *mut nsIAtom; - #[link_name = "?indeterminate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_indeterminate: *mut nsIAtom; - #[link_name = "?index@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_index: *mut nsIAtom; - #[link_name = "?infer@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_infer: *mut nsIAtom; - #[link_name = "?infinity@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_infinity: *mut nsIAtom; - #[link_name = "?inherit@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_inherit: *mut nsIAtom; - #[link_name = "?inherits@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_inherits: *mut nsIAtom; - #[link_name = "?inheritstyle@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_inheritstyle: *mut nsIAtom; - #[link_name = "?initial_scale@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_initial_scale: *mut nsIAtom; - #[link_name = "?input@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_input: *mut nsIAtom; - #[link_name = "?inputmode@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_inputmode: *mut nsIAtom; - #[link_name = "?ins@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ins: *mut nsIAtom; - #[link_name = "?insertafter@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_insertafter: *mut nsIAtom; - #[link_name = "?insertbefore@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_insertbefore: *mut nsIAtom; - #[link_name = "?install@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_install: *mut nsIAtom; - #[link_name = "?instanceOf@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_instanceOf: *mut nsIAtom; - #[link_name = "?int32@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_int32: *mut nsIAtom; - #[link_name = "?int64@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_int64: *mut nsIAtom; - #[link_name = "?integer@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_integer: *mut nsIAtom; - #[link_name = "?integrity@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_integrity: *mut nsIAtom; - #[link_name = "?intersection@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_intersection: *mut nsIAtom; - #[link_name = "?is@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_is: *mut nsIAtom; - #[link_name = "?iscontainer@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_iscontainer: *mut nsIAtom; - #[link_name = "?isempty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_isempty: *mut nsIAtom; - #[link_name = "?ismap@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ismap: *mut nsIAtom; - #[link_name = "?itemid@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_itemid: *mut nsIAtom; - #[link_name = "?itemprop@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_itemprop: *mut nsIAtom; - #[link_name = "?itemref@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_itemref: *mut nsIAtom; - #[link_name = "?itemscope@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_itemscope: *mut nsIAtom; - #[link_name = "?itemtype@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_itemtype: *mut nsIAtom; - #[link_name = "?japanese_formal@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_japanese_formal: *mut nsIAtom; - #[link_name = "?japanese_informal@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_japanese_informal: *mut nsIAtom; - #[link_name = "?kbd@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_kbd: *mut nsIAtom; - #[link_name = "?keepcurrentinview@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_keepcurrentinview: *mut nsIAtom; - #[link_name = "?keepobjectsalive@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_keepobjectsalive: *mut nsIAtom; - #[link_name = "?key@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_key: *mut nsIAtom; - #[link_name = "?keycode@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_keycode: *mut nsIAtom; - #[link_name = "?keystatuseschange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_keystatuseschange: *mut nsIAtom; - #[link_name = "?keydown@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_keydown: *mut nsIAtom; - #[link_name = "?keygen@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_keygen: *mut nsIAtom; - #[link_name = "?keypress@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_keypress: *mut nsIAtom; - #[link_name = "?keyset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_keyset: *mut nsIAtom; - #[link_name = "?keysystem@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_keysystem: *mut nsIAtom; - #[link_name = "?keytext@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_keytext: *mut nsIAtom; - #[link_name = "?keyup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_keyup: *mut nsIAtom; - #[link_name = "?kind@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_kind: *mut nsIAtom; - #[link_name = "?korean_hangul_formal@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_korean_hangul_formal: *mut nsIAtom; - #[link_name = "?korean_hanja_formal@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_korean_hanja_formal: *mut nsIAtom; - #[link_name = "?korean_hanja_informal@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_korean_hanja_informal: *mut nsIAtom; - #[link_name = "?label@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_label: *mut nsIAtom; - #[link_name = "?labels@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_labels: *mut nsIAtom; - #[link_name = "?lang@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lang: *mut nsIAtom; - #[link_name = "?language@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_language: *mut nsIAtom; - #[link_name = "?last@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_last: *mut nsIAtom; - #[link_name = "?layer@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_layer: *mut nsIAtom; - #[link_name = "?LayerActivity@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_LayerActivity: *mut nsIAtom; - #[link_name = "?layout@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_layout: *mut nsIAtom; - #[link_name = "?leading@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_leading: *mut nsIAtom; - #[link_name = "?leaf@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_leaf: *mut nsIAtom; - #[link_name = "?left@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_left: *mut nsIAtom; - #[link_name = "?leftmargin@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_leftmargin: *mut nsIAtom; - #[link_name = "?leftpadding@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_leftpadding: *mut nsIAtom; - #[link_name = "?legend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_legend: *mut nsIAtom; - #[link_name = "?length@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_length: *mut nsIAtom; - #[link_name = "?letterValue@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_letterValue: *mut nsIAtom; - #[link_name = "?level@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_level: *mut nsIAtom; - #[link_name = "?li@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_li: *mut nsIAtom; - #[link_name = "?line@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_line: *mut nsIAtom; - #[link_name = "?link@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_link: *mut nsIAtom; - #[link_name = "?list@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_list: *mut nsIAtom; - #[link_name = "?listbox@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_listbox: *mut nsIAtom; - #[link_name = "?listboxbody@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_listboxbody: *mut nsIAtom; - #[link_name = "?listcell@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_listcell: *mut nsIAtom; - #[link_name = "?listcol@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_listcol: *mut nsIAtom; - #[link_name = "?listcols@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_listcols: *mut nsIAtom; - #[link_name = "?listener@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_listener: *mut nsIAtom; - #[link_name = "?listhead@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_listhead: *mut nsIAtom; - #[link_name = "?listheader@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_listheader: *mut nsIAtom; - #[link_name = "?listing@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_listing: *mut nsIAtom; - #[link_name = "?listitem@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_listitem: *mut nsIAtom; - #[link_name = "?listrows@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_listrows: *mut nsIAtom; - #[link_name = "?load@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_load: *mut nsIAtom; - #[link_name = "?loadingprincipal@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_loadingprincipal: *mut nsIAtom; - #[link_name = "?localedir@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_localedir: *mut nsIAtom; - #[link_name = "?localName@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_localName: *mut nsIAtom; - #[link_name = "?longdesc@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_longdesc: *mut nsIAtom; - #[link_name = "?loop@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_loop: *mut nsIAtom; - #[link_name = "?low@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_low: *mut nsIAtom; - #[link_name = "?lowerAlpha@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lowerAlpha: *mut nsIAtom; - #[link_name = "?lowerFirst@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lowerFirst: *mut nsIAtom; - #[link_name = "?lowerRoman@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lowerRoman: *mut nsIAtom; - #[link_name = "?lowest@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lowest: *mut nsIAtom; - #[link_name = "?lowsrc@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lowsrc: *mut nsIAtom; - #[link_name = "?ltr@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ltr: *mut nsIAtom; - #[link_name = "?lwtheme@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lwtheme: *mut nsIAtom; - #[link_name = "?lwthemetextcolor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lwthemetextcolor: *mut nsIAtom; - #[link_name = "?main@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_main: *mut nsIAtom; - #[link_name = "?map@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_map: *mut nsIAtom; - #[link_name = "?manifest@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_manifest: *mut nsIAtom; - #[link_name = "?marginBottom@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_marginBottom: *mut nsIAtom; - #[link_name = "?marginLeft@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_marginLeft: *mut nsIAtom; - #[link_name = "?marginRight@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_marginRight: *mut nsIAtom; - #[link_name = "?marginTop@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_marginTop: *mut nsIAtom; - #[link_name = "?marginheight@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_marginheight: *mut nsIAtom; - #[link_name = "?marginwidth@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_marginwidth: *mut nsIAtom; - #[link_name = "?mark@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mark: *mut nsIAtom; - #[link_name = "?marquee@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_marquee: *mut nsIAtom; - #[link_name = "?match@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_match: *mut nsIAtom; - #[link_name = "?max@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_max: *mut nsIAtom; - #[link_name = "?maxheight@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_maxheight: *mut nsIAtom; - #[link_name = "?maximum_scale@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_maximum_scale: *mut nsIAtom; - #[link_name = "?maxlength@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_maxlength: *mut nsIAtom; - #[link_name = "?maxpos@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_maxpos: *mut nsIAtom; - #[link_name = "?maxwidth@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_maxwidth: *mut nsIAtom; - #[link_name = "?mayscript@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mayscript: *mut nsIAtom; - #[link_name = "?media@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_media: *mut nsIAtom; - #[link_name = "?mediaType@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mediaType: *mut nsIAtom; - #[link_name = "?member@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_member: *mut nsIAtom; - #[link_name = "?menu@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_menu: *mut nsIAtom; - #[link_name = "?menubar@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_menubar: *mut nsIAtom; - #[link_name = "?menubutton@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_menubutton: *mut nsIAtom; - #[link_name = "?menuButton@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_menuButton: *mut nsIAtom; - #[link_name = "?menugroup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_menugroup: *mut nsIAtom; - #[link_name = "?menuitem@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_menuitem: *mut nsIAtom; - #[link_name = "?menulist@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_menulist: *mut nsIAtom; - #[link_name = "?menupopup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_menupopup: *mut nsIAtom; - #[link_name = "?menuseparator@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_menuseparator: *mut nsIAtom; - #[link_name = "?message@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_message: *mut nsIAtom; - #[link_name = "?meta@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_meta: *mut nsIAtom; - #[link_name = "?referrer@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_referrer: *mut nsIAtom; - #[link_name = "?referrerpolicy@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_referrerpolicy: *mut nsIAtom; - #[link_name = "?headerReferrerPolicy@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_headerReferrerPolicy: *mut nsIAtom; - #[link_name = "?meter@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_meter: *mut nsIAtom; - #[link_name = "?method@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_method: *mut nsIAtom; - #[link_name = "?middle@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_middle: *mut nsIAtom; - #[link_name = "?min@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_min: *mut nsIAtom; - #[link_name = "?minheight@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_minheight: *mut nsIAtom; - #[link_name = "?minimum_scale@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_minimum_scale: *mut nsIAtom; - #[link_name = "?minlength@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_minlength: *mut nsIAtom; - #[link_name = "?minpos@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_minpos: *mut nsIAtom; - #[link_name = "?minusSign@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_minusSign: *mut nsIAtom; - #[link_name = "?minwidth@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_minwidth: *mut nsIAtom; - #[link_name = "?_mixed@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__mixed: *mut nsIAtom; - #[link_name = "?messagemanagergroup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_messagemanagergroup: *mut nsIAtom; - #[link_name = "?mod@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mod: *mut nsIAtom; - #[link_name = "?mode@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mode: *mut nsIAtom; - #[link_name = "?modifiers@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_modifiers: *mut nsIAtom; - #[link_name = "?monochrome@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_monochrome: *mut nsIAtom; - #[link_name = "?mousedown@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mousedown: *mut nsIAtom; - #[link_name = "?mousemove@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mousemove: *mut nsIAtom; - #[link_name = "?mouseout@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mouseout: *mut nsIAtom; - #[link_name = "?mouseover@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mouseover: *mut nsIAtom; - #[link_name = "?mousethrough@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mousethrough: *mut nsIAtom; - #[link_name = "?mouseup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mouseup: *mut nsIAtom; - #[link_name = "?mozfullscreenchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozfullscreenchange: *mut nsIAtom; - #[link_name = "?mozfullscreenerror@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozfullscreenerror: *mut nsIAtom; - #[link_name = "?mozpointerlockchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozpointerlockchange: *mut nsIAtom; - #[link_name = "?mozpointerlockerror@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozpointerlockerror: *mut nsIAtom; - #[link_name = "?mozprivatebrowsing@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozprivatebrowsing: *mut nsIAtom; - #[link_name = "?moz_opaque@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_moz_opaque: *mut nsIAtom; - #[link_name = "?moz_action_hint@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_moz_action_hint: *mut nsIAtom; - #[link_name = "?x_moz_errormessage@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x_moz_errormessage: *mut nsIAtom; - #[link_name = "?multicol@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_multicol: *mut nsIAtom; - #[link_name = "?multiple@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_multiple: *mut nsIAtom; - #[link_name = "?muted@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_muted: *mut nsIAtom; - #[link_name = "?name@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_name: *mut nsIAtom; - #[link_name = "?_namespace@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__namespace: *mut nsIAtom; - #[link_name = "?namespaceAlias@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_namespaceAlias: *mut nsIAtom; - #[link_name = "?namespaceUri@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_namespaceUri: *mut nsIAtom; - #[link_name = "?NaN@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_NaN: *mut nsIAtom; - #[link_name = "?nativeAnonymousChildList@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nativeAnonymousChildList: *mut nsIAtom; - #[link_name = "?nav@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nav: *mut nsIAtom; - #[link_name = "?negate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_negate: *mut nsIAtom; - #[link_name = "?never@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_never: *mut nsIAtom; - #[link_name = "?_new@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__new: *mut nsIAtom; - #[link_name = "?newline@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_newline: *mut nsIAtom; - #[link_name = "?nextBidi@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nextBidi: *mut nsIAtom; - #[link_name = "?nextTabParentId@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nextTabParentId: *mut nsIAtom; - #[link_name = "?no@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_no: *mut nsIAtom; - #[link_name = "?noautofocus@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_noautofocus: *mut nsIAtom; - #[link_name = "?noautohide@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_noautohide: *mut nsIAtom; - #[link_name = "?norolluponanchor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_norolluponanchor: *mut nsIAtom; - #[link_name = "?nobr@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nobr: *mut nsIAtom; - #[link_name = "?node@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_node: *mut nsIAtom; - #[link_name = "?nodefaultsrc@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nodefaultsrc: *mut nsIAtom; - #[link_name = "?nodeSet@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nodeSet: *mut nsIAtom; - #[link_name = "?noembed@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_noembed: *mut nsIAtom; - #[link_name = "?noframes@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_noframes: *mut nsIAtom; - #[link_name = "?nohref@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nohref: *mut nsIAtom; - #[link_name = "?noisolation@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_noisolation: *mut nsIAtom; - #[link_name = "?nomodule@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nomodule: *mut nsIAtom; - #[link_name = "?nonce@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nonce: *mut nsIAtom; - #[link_name = "?none@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_none: *mut nsIAtom; - #[link_name = "?noresize@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_noresize: *mut nsIAtom; - #[link_name = "?normal@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_normal: *mut nsIAtom; - #[link_name = "?normalizeSpace@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_normalizeSpace: *mut nsIAtom; - #[link_name = "?noscript@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_noscript: *mut nsIAtom; - #[link_name = "?noshade@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_noshade: *mut nsIAtom; - #[link_name = "?novalidate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_novalidate: *mut nsIAtom; - #[link_name = "?_not@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__not: *mut nsIAtom; - #[link_name = "?nowrap@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nowrap: *mut nsIAtom; - #[link_name = "?number@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_number: *mut nsIAtom; - #[link_name = "?null@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_null: *mut nsIAtom; - #[link_name = "?object@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_object: *mut nsIAtom; - #[link_name = "?objectType@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_objectType: *mut nsIAtom; - #[link_name = "?observer@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_observer: *mut nsIAtom; - #[link_name = "?observes@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_observes: *mut nsIAtom; - #[link_name = "?odd@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_odd: *mut nsIAtom; - #[link_name = "?OFF@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_OFF: *mut nsIAtom; - #[link_name = "?ol@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ol: *mut nsIAtom; - #[link_name = "?omitXmlDeclaration@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_omitXmlDeclaration: *mut nsIAtom; - #[link_name = "?ona2dpstatuschanged@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ona2dpstatuschanged: *mut nsIAtom; - #[link_name = "?onabort@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onabort: *mut nsIAtom; - #[link_name = "?onmozaccesskeynotfound@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmozaccesskeynotfound: *mut nsIAtom; - #[link_name = "?onactivate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onactivate: *mut nsIAtom; - #[link_name = "?onadapteradded@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onadapteradded: *mut nsIAtom; - #[link_name = "?onadapterremoved@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onadapterremoved: *mut nsIAtom; - #[link_name = "?onafterprint@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onafterprint: *mut nsIAtom; - #[link_name = "?onafterscriptexecute@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onafterscriptexecute: *mut nsIAtom; - #[link_name = "?onalerting@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onalerting: *mut nsIAtom; - #[link_name = "?onanimationcancel@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onanimationcancel: *mut nsIAtom; - #[link_name = "?onanimationend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onanimationend: *mut nsIAtom; - #[link_name = "?onanimationiteration@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onanimationiteration: *mut nsIAtom; - #[link_name = "?onanimationstart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onanimationstart: *mut nsIAtom; - #[link_name = "?onantennaavailablechange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onantennaavailablechange: *mut nsIAtom; - #[link_name = "?onAppCommand@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onAppCommand: *mut nsIAtom; - #[link_name = "?onappinstalled@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onappinstalled: *mut nsIAtom; - #[link_name = "?onattributechanged@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onattributechanged: *mut nsIAtom; - #[link_name = "?onattributereadreq@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onattributereadreq: *mut nsIAtom; - #[link_name = "?onattributewritereq@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onattributewritereq: *mut nsIAtom; - #[link_name = "?onaudioprocess@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onaudioprocess: *mut nsIAtom; - #[link_name = "?onauxclick@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onauxclick: *mut nsIAtom; - #[link_name = "?onbeforecopy@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onbeforecopy: *mut nsIAtom; - #[link_name = "?onbeforecut@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onbeforecut: *mut nsIAtom; - #[link_name = "?onbeforepaste@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onbeforepaste: *mut nsIAtom; - #[link_name = "?onbeforeevicted@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onbeforeevicted: *mut nsIAtom; - #[link_name = "?onbeforeprint@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onbeforeprint: *mut nsIAtom; - #[link_name = "?onbeforescriptexecute@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onbeforescriptexecute: *mut nsIAtom; - #[link_name = "?onbeforeunload@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onbeforeunload: *mut nsIAtom; - #[link_name = "?onblocked@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onblocked: *mut nsIAtom; - #[link_name = "?onblur@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onblur: *mut nsIAtom; - #[link_name = "?onbroadcast@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onbroadcast: *mut nsIAtom; - #[link_name = "?onbusy@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onbusy: *mut nsIAtom; - #[link_name = "?onbufferedamountlow@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onbufferedamountlow: *mut nsIAtom; - #[link_name = "?oncached@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncached: *mut nsIAtom; - #[link_name = "?oncallschanged@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncallschanged: *mut nsIAtom; - #[link_name = "?oncancel@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncancel: *mut nsIAtom; - #[link_name = "?oncardstatechange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncardstatechange: *mut nsIAtom; - #[link_name = "?oncfstatechange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncfstatechange: *mut nsIAtom; - #[link_name = "?onchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onchange: *mut nsIAtom; - #[link_name = "?oncharacteristicchanged@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncharacteristicchanged: *mut nsIAtom; - #[link_name = "?onchargingchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onchargingchange: *mut nsIAtom; - #[link_name = "?onchargingtimechange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onchargingtimechange: *mut nsIAtom; - #[link_name = "?onchecking@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onchecking: *mut nsIAtom; - #[link_name = "?onCheckboxStateChange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onCheckboxStateChange: *mut nsIAtom; - #[link_name = "?onclick@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onclick: *mut nsIAtom; - #[link_name = "?onclirmodechange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onclirmodechange: *mut nsIAtom; - #[link_name = "?onclose@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onclose: *mut nsIAtom; - #[link_name = "?oncommand@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncommand: *mut nsIAtom; - #[link_name = "?oncommandupdate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncommandupdate: *mut nsIAtom; - #[link_name = "?oncomplete@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncomplete: *mut nsIAtom; - #[link_name = "?oncompositionend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncompositionend: *mut nsIAtom; - #[link_name = "?oncompositionstart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncompositionstart: *mut nsIAtom; - #[link_name = "?oncompositionupdate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncompositionupdate: *mut nsIAtom; - #[link_name = "?onconnect@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onconnect: *mut nsIAtom; - #[link_name = "?onconnected@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onconnected: *mut nsIAtom; - #[link_name = "?onconnecting@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onconnecting: *mut nsIAtom; - #[link_name = "?onconnectionavailable@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onconnectionavailable: *mut nsIAtom; - #[link_name = "?onconnectionstatechanged@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onconnectionstatechanged: *mut nsIAtom; - #[link_name = "?oncontextmenu@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncontextmenu: *mut nsIAtom; - #[link_name = "?oncopy@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncopy: *mut nsIAtom; - #[link_name = "?oncurrentchannelchanged@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncurrentchannelchanged: *mut nsIAtom; - #[link_name = "?oncurrentsourcechanged@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncurrentsourcechanged: *mut nsIAtom; - #[link_name = "?oncut@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncut: *mut nsIAtom; - #[link_name = "?ondatachange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondatachange: *mut nsIAtom; - #[link_name = "?ondataerror@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondataerror: *mut nsIAtom; - #[link_name = "?ondblclick@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondblclick: *mut nsIAtom; - #[link_name = "?ondeleted@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondeleted: *mut nsIAtom; - #[link_name = "?ondeliverysuccess@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondeliverysuccess: *mut nsIAtom; - #[link_name = "?ondeliveryerror@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondeliveryerror: *mut nsIAtom; - #[link_name = "?ondevicefound@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondevicefound: *mut nsIAtom; - #[link_name = "?ondevicepaired@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondevicepaired: *mut nsIAtom; - #[link_name = "?ondeviceunpaired@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondeviceunpaired: *mut nsIAtom; - #[link_name = "?ondialing@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondialing: *mut nsIAtom; - #[link_name = "?ondisabled@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondisabled: *mut nsIAtom; - #[link_name = "?ondischargingtimechange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondischargingtimechange: *mut nsIAtom; - #[link_name = "?ondisconnect@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondisconnect: *mut nsIAtom; - #[link_name = "?ondisconnected@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondisconnected: *mut nsIAtom; - #[link_name = "?ondisconnecting@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondisconnecting: *mut nsIAtom; - #[link_name = "?ondisplaypasskeyreq@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondisplaypasskeyreq: *mut nsIAtom; - #[link_name = "?ondownloading@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondownloading: *mut nsIAtom; - #[link_name = "?onDOMActivate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onDOMActivate: *mut nsIAtom; - #[link_name = "?onDOMAttrModified@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onDOMAttrModified: *mut nsIAtom; - #[link_name = "?onDOMCharacterDataModified@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onDOMCharacterDataModified: *mut nsIAtom; - #[link_name = "?onDOMFocusIn@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onDOMFocusIn: *mut nsIAtom; - #[link_name = "?onDOMFocusOut@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onDOMFocusOut: *mut nsIAtom; - #[link_name = "?onDOMMouseScroll@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onDOMMouseScroll: *mut nsIAtom; - #[link_name = "?onDOMNodeInserted@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onDOMNodeInserted: *mut nsIAtom; - #[link_name = "?onDOMNodeInsertedIntoDocument@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onDOMNodeInsertedIntoDocument: *mut nsIAtom; - #[link_name = "?onDOMNodeRemoved@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onDOMNodeRemoved: *mut nsIAtom; - #[link_name = "?onDOMNodeRemovedFromDocument@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onDOMNodeRemovedFromDocument: *mut nsIAtom; - #[link_name = "?onDOMSubtreeModified@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onDOMSubtreeModified: *mut nsIAtom; - #[link_name = "?ondata@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondata: *mut nsIAtom; - #[link_name = "?ondrag@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondrag: *mut nsIAtom; - #[link_name = "?ondragdrop@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondragdrop: *mut nsIAtom; - #[link_name = "?ondragend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondragend: *mut nsIAtom; - #[link_name = "?ondragenter@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondragenter: *mut nsIAtom; - #[link_name = "?ondragexit@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondragexit: *mut nsIAtom; - #[link_name = "?ondraggesture@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondraggesture: *mut nsIAtom; - #[link_name = "?ondragleave@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondragleave: *mut nsIAtom; - #[link_name = "?ondragover@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondragover: *mut nsIAtom; - #[link_name = "?ondragstart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondragstart: *mut nsIAtom; - #[link_name = "?ondrain@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondrain: *mut nsIAtom; - #[link_name = "?ondrop@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondrop: *mut nsIAtom; - #[link_name = "?oneitbroadcasted@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oneitbroadcasted: *mut nsIAtom; - #[link_name = "?onenabled@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onenabled: *mut nsIAtom; - #[link_name = "?onenterpincodereq@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onenterpincodereq: *mut nsIAtom; - #[link_name = "?onemergencycbmodechange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onemergencycbmodechange: *mut nsIAtom; - #[link_name = "?onerror@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onerror: *mut nsIAtom; - #[link_name = "?onevicted@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onevicted: *mut nsIAtom; - #[link_name = "?onfailed@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onfailed: *mut nsIAtom; - #[link_name = "?onfetch@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onfetch: *mut nsIAtom; - #[link_name = "?onfinish@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onfinish: *mut nsIAtom; - #[link_name = "?onfocus@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onfocus: *mut nsIAtom; - #[link_name = "?onfocusin@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onfocusin: *mut nsIAtom; - #[link_name = "?onfocusout@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onfocusout: *mut nsIAtom; - #[link_name = "?onfrequencychange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onfrequencychange: *mut nsIAtom; - #[link_name = "?onfullscreenchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onfullscreenchange: *mut nsIAtom; - #[link_name = "?onfullscreenerror@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onfullscreenerror: *mut nsIAtom; - #[link_name = "?onspeakerforcedchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onspeakerforcedchange: *mut nsIAtom; - #[link_name = "?onget@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onget: *mut nsIAtom; - #[link_name = "?ongroupchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ongroupchange: *mut nsIAtom; - #[link_name = "?onhashchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onhashchange: *mut nsIAtom; - #[link_name = "?onheadphoneschange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onheadphoneschange: *mut nsIAtom; - #[link_name = "?onheld@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onheld: *mut nsIAtom; - #[link_name = "?onhfpstatuschanged@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onhfpstatuschanged: *mut nsIAtom; - #[link_name = "?onhidstatuschanged@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onhidstatuschanged: *mut nsIAtom; - #[link_name = "?onholding@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onholding: *mut nsIAtom; - #[link_name = "?oniccchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oniccchange: *mut nsIAtom; - #[link_name = "?oniccdetected@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oniccdetected: *mut nsIAtom; - #[link_name = "?oniccinfochange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oniccinfochange: *mut nsIAtom; - #[link_name = "?oniccundetected@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oniccundetected: *mut nsIAtom; - #[link_name = "?onincoming@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onincoming: *mut nsIAtom; - #[link_name = "?oninput@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oninput: *mut nsIAtom; - #[link_name = "?oninstall@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oninstall: *mut nsIAtom; - #[link_name = "?oninvalid@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oninvalid: *mut nsIAtom; - #[link_name = "?onkeydown@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onkeydown: *mut nsIAtom; - #[link_name = "?onkeypress@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onkeypress: *mut nsIAtom; - #[link_name = "?onkeyup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onkeyup: *mut nsIAtom; - #[link_name = "?onlanguagechange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onlanguagechange: *mut nsIAtom; - #[link_name = "?onlevelchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onlevelchange: *mut nsIAtom; - #[link_name = "?onLoad@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onLoad: *mut nsIAtom; - #[link_name = "?onload@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onload: *mut nsIAtom; - #[link_name = "?onloading@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onloading: *mut nsIAtom; - #[link_name = "?onloadingdone@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onloadingdone: *mut nsIAtom; - #[link_name = "?onloadingerror@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onloadingerror: *mut nsIAtom; - #[link_name = "?onpopstate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpopstate: *mut nsIAtom; - #[link_name = "?only@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_only: *mut nsIAtom; - #[link_name = "?onmessage@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmessage: *mut nsIAtom; - #[link_name = "?onmessageerror@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmessageerror: *mut nsIAtom; - #[link_name = "?onmousedown@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmousedown: *mut nsIAtom; - #[link_name = "?onmouseenter@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmouseenter: *mut nsIAtom; - #[link_name = "?onmouseleave@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmouseleave: *mut nsIAtom; - #[link_name = "?onmouselongtap@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmouselongtap: *mut nsIAtom; - #[link_name = "?onmousemove@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmousemove: *mut nsIAtom; - #[link_name = "?onmouseout@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmouseout: *mut nsIAtom; - #[link_name = "?onmouseover@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmouseover: *mut nsIAtom; - #[link_name = "?onMozMouseHittest@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onMozMouseHittest: *mut nsIAtom; - #[link_name = "?onmouseup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmouseup: *mut nsIAtom; - #[link_name = "?onMozAfterPaint@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onMozAfterPaint: *mut nsIAtom; - #[link_name = "?onmozfullscreenchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmozfullscreenchange: *mut nsIAtom; - #[link_name = "?onmozfullscreenerror@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmozfullscreenerror: *mut nsIAtom; - #[link_name = "?onmozkeydownonplugin@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmozkeydownonplugin: *mut nsIAtom; - #[link_name = "?onmozkeyuponplugin@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmozkeyuponplugin: *mut nsIAtom; - #[link_name = "?onmozpointerlockchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmozpointerlockchange: *mut nsIAtom; - #[link_name = "?onmozpointerlockerror@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmozpointerlockerror: *mut nsIAtom; - #[link_name = "?onMozMousePixelScroll@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onMozMousePixelScroll: *mut nsIAtom; - #[link_name = "?onMozScrolledAreaChanged@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onMozScrolledAreaChanged: *mut nsIAtom; - #[link_name = "?onmapfolderlistingreq@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmapfolderlistingreq: *mut nsIAtom; - #[link_name = "?onmapmessageslistingreq@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmapmessageslistingreq: *mut nsIAtom; - #[link_name = "?onmapgetmessagereq@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmapgetmessagereq: *mut nsIAtom; - #[link_name = "?onmapsetmessagestatusreq@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmapsetmessagestatusreq: *mut nsIAtom; - #[link_name = "?onmapsendmessagereq@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmapsendmessagereq: *mut nsIAtom; - #[link_name = "?onmapmessageupdatereq@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmapmessageupdatereq: *mut nsIAtom; - #[link_name = "?onnewrdsgroup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onnewrdsgroup: *mut nsIAtom; - #[link_name = "?onnotificationclick@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onnotificationclick: *mut nsIAtom; - #[link_name = "?onnotificationclose@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onnotificationclose: *mut nsIAtom; - #[link_name = "?onnoupdate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onnoupdate: *mut nsIAtom; - #[link_name = "?onobexpasswordreq@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onobexpasswordreq: *mut nsIAtom; - #[link_name = "?onobsolete@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onobsolete: *mut nsIAtom; - #[link_name = "?ononline@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ononline: *mut nsIAtom; - #[link_name = "?onoffline@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onoffline: *mut nsIAtom; - #[link_name = "?onopen@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onopen: *mut nsIAtom; - #[link_name = "?onorientationchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onorientationchange: *mut nsIAtom; - #[link_name = "?onotastatuschange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onotastatuschange: *mut nsIAtom; - #[link_name = "?onoverflow@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onoverflow: *mut nsIAtom; - #[link_name = "?onoverflowchanged@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onoverflowchanged: *mut nsIAtom; - #[link_name = "?onpagehide@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpagehide: *mut nsIAtom; - #[link_name = "?onpageshow@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpageshow: *mut nsIAtom; - #[link_name = "?onpaint@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpaint: *mut nsIAtom; - #[link_name = "?onpairingaborted@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpairingaborted: *mut nsIAtom; - #[link_name = "?onpairingconfirmationreq@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpairingconfirmationreq: *mut nsIAtom; - #[link_name = "?onpairingconsentreq@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpairingconsentreq: *mut nsIAtom; - #[link_name = "?onpaste@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpaste: *mut nsIAtom; - #[link_name = "?onpendingchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpendingchange: *mut nsIAtom; - #[link_name = "?onpichange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpichange: *mut nsIAtom; - #[link_name = "?onpointerlockchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpointerlockchange: *mut nsIAtom; - #[link_name = "?onpointerlockerror@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpointerlockerror: *mut nsIAtom; - #[link_name = "?onpopuphidden@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpopuphidden: *mut nsIAtom; - #[link_name = "?onpopuphiding@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpopuphiding: *mut nsIAtom; - #[link_name = "?onpopuppositioned@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpopuppositioned: *mut nsIAtom; - #[link_name = "?onpopupshowing@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpopupshowing: *mut nsIAtom; - #[link_name = "?onpopupshown@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpopupshown: *mut nsIAtom; - #[link_name = "?onpullphonebookreq@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpullphonebookreq: *mut nsIAtom; - #[link_name = "?onpullvcardentryreq@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpullvcardentryreq: *mut nsIAtom; - #[link_name = "?onpullvcardlistingreq@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpullvcardlistingreq: *mut nsIAtom; - #[link_name = "?onpush@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpush: *mut nsIAtom; - #[link_name = "?onpushsubscriptionchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpushsubscriptionchange: *mut nsIAtom; - #[link_name = "?onpschange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpschange: *mut nsIAtom; - #[link_name = "?onptychange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onptychange: *mut nsIAtom; - #[link_name = "?onradiostatechange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onradiostatechange: *mut nsIAtom; - #[link_name = "?onRadioStateChange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onRadioStateChange: *mut nsIAtom; - #[link_name = "?onrdsdisabled@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onrdsdisabled: *mut nsIAtom; - #[link_name = "?onrdsenabled@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onrdsenabled: *mut nsIAtom; - #[link_name = "?onreaderror@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onreaderror: *mut nsIAtom; - #[link_name = "?onreadsuccess@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onreadsuccess: *mut nsIAtom; - #[link_name = "?onready@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onready: *mut nsIAtom; - #[link_name = "?onreadystatechange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onreadystatechange: *mut nsIAtom; - #[link_name = "?onreceived@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onreceived: *mut nsIAtom; - #[link_name = "?onremoteheld@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onremoteheld: *mut nsIAtom; - #[link_name = "?onremoteresumed@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onremoteresumed: *mut nsIAtom; - #[link_name = "?onrequestprogress@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onrequestprogress: *mut nsIAtom; - #[link_name = "?onresourcetimingbufferfull@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onresourcetimingbufferfull: *mut nsIAtom; - #[link_name = "?onresponseprogress@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onresponseprogress: *mut nsIAtom; - #[link_name = "?onretrieving@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onretrieving: *mut nsIAtom; - #[link_name = "?onRequest@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onRequest: *mut nsIAtom; - #[link_name = "?onrequestmediaplaystatus@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onrequestmediaplaystatus: *mut nsIAtom; - #[link_name = "?onreset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onreset: *mut nsIAtom; - #[link_name = "?onresuming@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onresuming: *mut nsIAtom; - #[link_name = "?onresize@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onresize: *mut nsIAtom; - #[link_name = "?onrtchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onrtchange: *mut nsIAtom; - #[link_name = "?onscanningstatechanged@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onscanningstatechanged: *mut nsIAtom; - #[link_name = "?onscostatuschanged@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onscostatuschanged: *mut nsIAtom; - #[link_name = "?onscroll@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onscroll: *mut nsIAtom; - #[link_name = "?onselect@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onselect: *mut nsIAtom; - #[link_name = "?onselectionchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onselectionchange: *mut nsIAtom; - #[link_name = "?onselectstart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onselectstart: *mut nsIAtom; - #[link_name = "?onsending@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onsending: *mut nsIAtom; - #[link_name = "?onsent@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onsent: *mut nsIAtom; - #[link_name = "?onset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onset: *mut nsIAtom; - #[link_name = "?onshippingaddresschange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onshippingaddresschange: *mut nsIAtom; - #[link_name = "?onshippingoptionchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onshippingoptionchange: *mut nsIAtom; - #[link_name = "?onshow@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onshow: *mut nsIAtom; - #[link_name = "?onstatechange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onstatechange: *mut nsIAtom; - #[link_name = "?onstatuschanged@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onstatuschanged: *mut nsIAtom; - #[link_name = "?onstkcommand@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onstkcommand: *mut nsIAtom; - #[link_name = "?onstksessionend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onstksessionend: *mut nsIAtom; - #[link_name = "?onstorage@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onstorage: *mut nsIAtom; - #[link_name = "?onstorageareachanged@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onstorageareachanged: *mut nsIAtom; - #[link_name = "?onsubmit@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onsubmit: *mut nsIAtom; - #[link_name = "?onsuccess@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onsuccess: *mut nsIAtom; - #[link_name = "?ontypechange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ontypechange: *mut nsIAtom; - #[link_name = "?onterminate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onterminate: *mut nsIAtom; - #[link_name = "?ontext@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ontext: *mut nsIAtom; - #[link_name = "?ontoggle@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ontoggle: *mut nsIAtom; - #[link_name = "?ontouchstart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ontouchstart: *mut nsIAtom; - #[link_name = "?ontouchend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ontouchend: *mut nsIAtom; - #[link_name = "?ontouchmove@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ontouchmove: *mut nsIAtom; - #[link_name = "?ontouchcancel@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ontouchcancel: *mut nsIAtom; - #[link_name = "?ontransitioncancel@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ontransitioncancel: *mut nsIAtom; - #[link_name = "?ontransitionend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ontransitionend: *mut nsIAtom; - #[link_name = "?ontransitionrun@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ontransitionrun: *mut nsIAtom; - #[link_name = "?ontransitionstart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ontransitionstart: *mut nsIAtom; - #[link_name = "?onunderflow@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onunderflow: *mut nsIAtom; - #[link_name = "?onunload@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onunload: *mut nsIAtom; - #[link_name = "?onupdatefound@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onupdatefound: *mut nsIAtom; - #[link_name = "?onupdateready@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onupdateready: *mut nsIAtom; - #[link_name = "?onupgradeneeded@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onupgradeneeded: *mut nsIAtom; - #[link_name = "?onussdreceived@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onussdreceived: *mut nsIAtom; - #[link_name = "?onversionchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onversionchange: *mut nsIAtom; - #[link_name = "?onvisibilitychange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onvisibilitychange: *mut nsIAtom; - #[link_name = "?onvoicechange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onvoicechange: *mut nsIAtom; - #[link_name = "?onvoiceschanged@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onvoiceschanged: *mut nsIAtom; - #[link_name = "?onvrdisplayactivate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onvrdisplayactivate: *mut nsIAtom; - #[link_name = "?onvrdisplayconnect@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onvrdisplayconnect: *mut nsIAtom; - #[link_name = "?onvrdisplaydeactivate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onvrdisplaydeactivate: *mut nsIAtom; - #[link_name = "?onvrdisplaydisconnect@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onvrdisplaydisconnect: *mut nsIAtom; - #[link_name = "?onvrdisplaypresentchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onvrdisplaypresentchange: *mut nsIAtom; - #[link_name = "?onwebkitAnimationEnd@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onwebkitAnimationEnd: *mut nsIAtom; - #[link_name = "?onwebkitAnimationIteration@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onwebkitAnimationIteration: *mut nsIAtom; - #[link_name = "?onwebkitAnimationStart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onwebkitAnimationStart: *mut nsIAtom; - #[link_name = "?onwebkitTransitionEnd@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onwebkitTransitionEnd: *mut nsIAtom; - #[link_name = "?onwebkitanimationend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onwebkitanimationend: *mut nsIAtom; - #[link_name = "?onwebkitanimationiteration@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onwebkitanimationiteration: *mut nsIAtom; - #[link_name = "?onwebkitanimationstart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onwebkitanimationstart: *mut nsIAtom; - #[link_name = "?onwebkittransitionend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onwebkittransitionend: *mut nsIAtom; - #[link_name = "?onwebsocket@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onwebsocket: *mut nsIAtom; - #[link_name = "?onwheel@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onwheel: *mut nsIAtom; - #[link_name = "?open@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_open: *mut nsIAtom; - #[link_name = "?optgroup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_optgroup: *mut nsIAtom; - #[link_name = "?optimum@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_optimum: *mut nsIAtom; - #[link_name = "?option@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_option: *mut nsIAtom; - #[link_name = "?_or@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__or: *mut nsIAtom; - #[link_name = "?order@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_order: *mut nsIAtom; - #[link_name = "?ordinal@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ordinal: *mut nsIAtom; - #[link_name = "?orient@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_orient: *mut nsIAtom; - #[link_name = "?orientation@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_orientation: *mut nsIAtom; - #[link_name = "?otherwise@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_otherwise: *mut nsIAtom; - #[link_name = "?output@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_output: *mut nsIAtom; - #[link_name = "?overflow@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_overflow: *mut nsIAtom; - #[link_name = "?overflowchanged@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_overflowchanged: *mut nsIAtom; - #[link_name = "?overlay@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_overlay: *mut nsIAtom; - #[link_name = "?overlap@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_overlap: *mut nsIAtom; - #[link_name = "?p@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_p: *mut nsIAtom; - #[link_name = "?pack@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pack: *mut nsIAtom; - #[link_name = "?page@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_page: *mut nsIAtom; - #[link_name = "?pageincrement@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pageincrement: *mut nsIAtom; - #[link_name = "?pagex@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pagex: *mut nsIAtom; - #[link_name = "?pagey@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pagey: *mut nsIAtom; - #[link_name = "?paint_order@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_paint_order: *mut nsIAtom; - #[link_name = "?palettename@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_palettename: *mut nsIAtom; - #[link_name = "?panel@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_panel: *mut nsIAtom; - #[link_name = "?param@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_param: *mut nsIAtom; - #[link_name = "?parameter@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_parameter: *mut nsIAtom; - #[link_name = "?parent@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_parent: *mut nsIAtom; - #[link_name = "?parentfocused@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_parentfocused: *mut nsIAtom; - #[link_name = "?parsetype@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_parsetype: *mut nsIAtom; - #[link_name = "?password@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_password: *mut nsIAtom; - #[link_name = "?pattern@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pattern: *mut nsIAtom; - #[link_name = "?patternSeparator@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_patternSeparator: *mut nsIAtom; - #[link_name = "?perMille@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_perMille: *mut nsIAtom; - #[link_name = "?percent@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_percent: *mut nsIAtom; - #[link_name = "?persist@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_persist: *mut nsIAtom; - #[link_name = "?phase@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_phase: *mut nsIAtom; - #[link_name = "?picture@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_picture: *mut nsIAtom; - #[link_name = "?ping@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ping: *mut nsIAtom; - #[link_name = "?pinned@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pinned: *mut nsIAtom; - #[link_name = "?placeholder@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_placeholder: *mut nsIAtom; - #[link_name = "?plaintext@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_plaintext: *mut nsIAtom; - #[link_name = "?playbackrate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_playbackrate: *mut nsIAtom; - #[link_name = "?pointSize@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pointSize: *mut nsIAtom; - #[link_name = "?pointerlockchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pointerlockchange: *mut nsIAtom; - #[link_name = "?pointerlockerror@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pointerlockerror: *mut nsIAtom; - #[link_name = "?poly@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_poly: *mut nsIAtom; - #[link_name = "?polygon@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_polygon: *mut nsIAtom; - #[link_name = "?popup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_popup: *mut nsIAtom; - #[link_name = "?popupalign@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_popupalign: *mut nsIAtom; - #[link_name = "?popupanchor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_popupanchor: *mut nsIAtom; - #[link_name = "?popupgroup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_popupgroup: *mut nsIAtom; - #[link_name = "?popuphidden@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_popuphidden: *mut nsIAtom; - #[link_name = "?popuphiding@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_popuphiding: *mut nsIAtom; - #[link_name = "?popupset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_popupset: *mut nsIAtom; - #[link_name = "?popupshowing@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_popupshowing: *mut nsIAtom; - #[link_name = "?popupshown@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_popupshown: *mut nsIAtom; - #[link_name = "?popupsinherittooltip@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_popupsinherittooltip: *mut nsIAtom; - #[link_name = "?position@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_position: *mut nsIAtom; - #[link_name = "?poster@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_poster: *mut nsIAtom; - #[link_name = "?pre@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pre: *mut nsIAtom; - #[link_name = "?preceding@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_preceding: *mut nsIAtom; - #[link_name = "?precedingSibling@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_precedingSibling: *mut nsIAtom; - #[link_name = "?predicate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_predicate: *mut nsIAtom; - #[link_name = "?prefix@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_prefix: *mut nsIAtom; - #[link_name = "?preload@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_preload: *mut nsIAtom; - #[link_name = "?prerendered@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_prerendered: *mut nsIAtom; - #[link_name = "?mozpresentation@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozpresentation: *mut nsIAtom; - #[link_name = "?preserve@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_preserve: *mut nsIAtom; - #[link_name = "?preserveSpace@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_preserveSpace: *mut nsIAtom; - #[link_name = "?preventdefault@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_preventdefault: *mut nsIAtom; - #[link_name = "?primary@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_primary: *mut nsIAtom; - #[link_name = "?print@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_print: *mut nsIAtom; - #[link_name = "?priority@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_priority: *mut nsIAtom; - #[link_name = "?processingInstruction@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_processingInstruction: *mut nsIAtom; - #[link_name = "?profile@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_profile: *mut nsIAtom; - #[link_name = "?progress@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_progress: *mut nsIAtom; - #[link_name = "?progressmeter@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_progressmeter: *mut nsIAtom; - #[link_name = "?progressNormal@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_progressNormal: *mut nsIAtom; - #[link_name = "?progressUndetermined@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_progressUndetermined: *mut nsIAtom; - #[link_name = "?projection@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_projection: *mut nsIAtom; - #[link_name = "?prompt@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_prompt: *mut nsIAtom; - #[link_name = "?propagate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_propagate: *mut nsIAtom; - #[link_name = "?properties@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_properties: *mut nsIAtom; - #[link_name = "?property@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_property: *mut nsIAtom; - #[link_name = "?pubdate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pubdate: *mut nsIAtom; - #[link_name = "?q@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_q: *mut nsIAtom; - #[link_name = "?query@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_query: *mut nsIAtom; - #[link_name = "?queryset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_queryset: *mut nsIAtom; - #[link_name = "?querytype@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_querytype: *mut nsIAtom; - #[link_name = "?radio@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_radio: *mut nsIAtom; - #[link_name = "?radiogroup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_radiogroup: *mut nsIAtom; - #[link_name = "?range@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_range: *mut nsIAtom; - #[link_name = "?readonly@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_readonly: *mut nsIAtom; - #[link_name = "?rect@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rect: *mut nsIAtom; - #[link_name = "?rectangle@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rectangle: *mut nsIAtom; - #[link_name = "?ref@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ref: *mut nsIAtom; - #[link_name = "?refresh@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_refresh: *mut nsIAtom; - #[link_name = "?rel@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rel: *mut nsIAtom; - #[link_name = "?onreloadpage@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onreloadpage: *mut nsIAtom; - #[link_name = "?rem@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rem: *mut nsIAtom; - #[link_name = "?remote@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_remote: *mut nsIAtom; - #[link_name = "?removeelement@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_removeelement: *mut nsIAtom; - #[link_name = "?renderingobserverlist@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_renderingobserverlist: *mut nsIAtom; - #[link_name = "?repeat@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_repeat: *mut nsIAtom; - #[link_name = "?replace@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_replace: *mut nsIAtom; - #[link_name = "?requestcontextid@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_requestcontextid: *mut nsIAtom; - #[link_name = "?required@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_required: *mut nsIAtom; - #[link_name = "?reserved@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_reserved: *mut nsIAtom; - #[link_name = "?reset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_reset: *mut nsIAtom; - #[link_name = "?resizeafter@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_resizeafter: *mut nsIAtom; - #[link_name = "?resizebefore@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_resizebefore: *mut nsIAtom; - #[link_name = "?resizer@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_resizer: *mut nsIAtom; - #[link_name = "?resolution@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_resolution: *mut nsIAtom; - #[link_name = "?resource@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_resource: *mut nsIAtom; - #[link_name = "?resources@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_resources: *mut nsIAtom; - #[link_name = "?result@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_result: *mut nsIAtom; - #[link_name = "?resultPrefix@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_resultPrefix: *mut nsIAtom; - #[link_name = "?retargetdocumentfocus@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_retargetdocumentfocus: *mut nsIAtom; - #[link_name = "?rev@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rev: *mut nsIAtom; - #[link_name = "?reverse@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_reverse: *mut nsIAtom; - #[link_name = "?reversed@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_reversed: *mut nsIAtom; - #[link_name = "?richlistbox@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_richlistbox: *mut nsIAtom; - #[link_name = "?richlistitem@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_richlistitem: *mut nsIAtom; - #[link_name = "?right@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_right: *mut nsIAtom; - #[link_name = "?rightmargin@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rightmargin: *mut nsIAtom; - #[link_name = "?rightpadding@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rightpadding: *mut nsIAtom; - #[link_name = "?role@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_role: *mut nsIAtom; - #[link_name = "?rolluponmousewheel@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rolluponmousewheel: *mut nsIAtom; - #[link_name = "?round@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_round: *mut nsIAtom; - #[link_name = "?row@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_row: *mut nsIAtom; - #[link_name = "?rows@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rows: *mut nsIAtom; - #[link_name = "?rowspan@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rowspan: *mut nsIAtom; - #[link_name = "?rb@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rb: *mut nsIAtom; - #[link_name = "?rp@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rp: *mut nsIAtom; - #[link_name = "?rt@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rt: *mut nsIAtom; - #[link_name = "?rtc@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rtc: *mut nsIAtom; - #[link_name = "?rtl@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rtl: *mut nsIAtom; - #[link_name = "?ruby@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ruby: *mut nsIAtom; - #[link_name = "?rubyBase@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rubyBase: *mut nsIAtom; - #[link_name = "?rubyBaseContainer@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rubyBaseContainer: *mut nsIAtom; - #[link_name = "?rubyText@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rubyText: *mut nsIAtom; - #[link_name = "?rubyTextContainer@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rubyTextContainer: *mut nsIAtom; - #[link_name = "?rule@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rule: *mut nsIAtom; - #[link_name = "?rules@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rules: *mut nsIAtom; - #[link_name = "?s@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_s: *mut nsIAtom; - #[link_name = "?samp@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_samp: *mut nsIAtom; - #[link_name = "?sandbox@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sandbox: *mut nsIAtom; - #[link_name = "?sbattr@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sbattr: *mut nsIAtom; - #[link_name = "?scale@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scale: *mut nsIAtom; - #[link_name = "?scan@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scan: *mut nsIAtom; - #[link_name = "?scheme@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scheme: *mut nsIAtom; - #[link_name = "?scope@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scope: *mut nsIAtom; - #[link_name = "?scoped@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scoped: *mut nsIAtom; - #[link_name = "?screen@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_screen: *mut nsIAtom; - #[link_name = "?screenX@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_screenX: *mut nsIAtom; - #[link_name = "?screenY@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_screenY: *mut nsIAtom; - #[link_name = "?script@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_script: *mut nsIAtom; - #[link_name = "?scriptEnabledBeforePrintOrPreview@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scriptEnabledBeforePrintOrPreview: *mut nsIAtom; - #[link_name = "?scrollbar@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scrollbar: *mut nsIAtom; - #[link_name = "?scrollbarbutton@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scrollbarbutton: *mut nsIAtom; - #[link_name = "?scrollbarDownBottom@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scrollbarDownBottom: *mut nsIAtom; - #[link_name = "?scrollbarDownTop@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scrollbarDownTop: *mut nsIAtom; - #[link_name = "?scrollbarUpBottom@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scrollbarUpBottom: *mut nsIAtom; - #[link_name = "?scrollbarUpTop@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scrollbarUpTop: *mut nsIAtom; - #[link_name = "?scrollbox@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scrollbox: *mut nsIAtom; - #[link_name = "?scrollcorner@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scrollcorner: *mut nsIAtom; - #[link_name = "?scrolling@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scrolling: *mut nsIAtom; - #[link_name = "?scrollPosition@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scrollPosition: *mut nsIAtom; - #[link_name = "?section@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_section: *mut nsIAtom; - #[link_name = "?select@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_select: *mut nsIAtom; - #[link_name = "?selectable@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_selectable: *mut nsIAtom; - #[link_name = "?selected@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_selected: *mut nsIAtom; - #[link_name = "?selectedIndex@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_selectedIndex: *mut nsIAtom; - #[link_name = "?selectedindex@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_selectedindex: *mut nsIAtom; - #[link_name = "?self@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_self: *mut nsIAtom; - #[link_name = "?seltype@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_seltype: *mut nsIAtom; - #[link_name = "?setcookie@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_setcookie: *mut nsIAtom; - #[link_name = "?setter@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_setter: *mut nsIAtom; - #[link_name = "?shape@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_shape: *mut nsIAtom; - #[link_name = "?show@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_show: *mut nsIAtom; - #[link_name = "?showcaret@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_showcaret: *mut nsIAtom; - #[link_name = "?showresizer@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_showresizer: *mut nsIAtom; - #[link_name = "?simple@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_simple: *mut nsIAtom; - #[link_name = "?simp_chinese_formal@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_simp_chinese_formal: *mut nsIAtom; - #[link_name = "?simp_chinese_informal@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_simp_chinese_informal: *mut nsIAtom; - #[link_name = "?single@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_single: *mut nsIAtom; - #[link_name = "?size@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_size: *mut nsIAtom; - #[link_name = "?sizes@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sizes: *mut nsIAtom; - #[link_name = "?sizemode@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sizemode: *mut nsIAtom; - #[link_name = "?sizetopopup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sizetopopup: *mut nsIAtom; - #[link_name = "?slider@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_slider: *mut nsIAtom; - #[link_name = "?small@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_small: *mut nsIAtom; - #[link_name = "?smooth@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_smooth: *mut nsIAtom; - #[link_name = "?snap@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_snap: *mut nsIAtom; - #[link_name = "?sort@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sort: *mut nsIAtom; - #[link_name = "?sortActive@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sortActive: *mut nsIAtom; - #[link_name = "?sortDirection@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sortDirection: *mut nsIAtom; - #[link_name = "?sorted@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sorted: *mut nsIAtom; - #[link_name = "?sorthints@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sorthints: *mut nsIAtom; - #[link_name = "?sortLocked@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sortLocked: *mut nsIAtom; - #[link_name = "?sortResource@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sortResource: *mut nsIAtom; - #[link_name = "?sortResource2@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sortResource2: *mut nsIAtom; - #[link_name = "?sortSeparators@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sortSeparators: *mut nsIAtom; - #[link_name = "?sortStaticsLast@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sortStaticsLast: *mut nsIAtom; - #[link_name = "?source@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_source: *mut nsIAtom; - #[link_name = "?space@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_space: *mut nsIAtom; - #[link_name = "?spacer@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_spacer: *mut nsIAtom; - #[link_name = "?span@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_span: *mut nsIAtom; - #[link_name = "?spellcheck@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_spellcheck: *mut nsIAtom; - #[link_name = "?spinner@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_spinner: *mut nsIAtom; - #[link_name = "?split@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_split: *mut nsIAtom; - #[link_name = "?splitter@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_splitter: *mut nsIAtom; - #[link_name = "?spring@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_spring: *mut nsIAtom; - #[link_name = "?square@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_square: *mut nsIAtom; - #[link_name = "?src@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_src: *mut nsIAtom; - #[link_name = "?srcdoc@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_srcdoc: *mut nsIAtom; - #[link_name = "?srclang@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_srclang: *mut nsIAtom; - #[link_name = "?srcset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_srcset: *mut nsIAtom; - #[link_name = "?stack@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stack: *mut nsIAtom; - #[link_name = "?standalone@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_standalone: *mut nsIAtom; - #[link_name = "?standby@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_standby: *mut nsIAtom; - #[link_name = "?start@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_start: *mut nsIAtom; - #[link_name = "?start_after@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_start_after: *mut nsIAtom; - #[link_name = "?start_before@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_start_before: *mut nsIAtom; - #[link_name = "?startsWith@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_startsWith: *mut nsIAtom; - #[link_name = "?state@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_state: *mut nsIAtom; - #[link_name = "?statedatasource@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_statedatasource: *mut nsIAtom; - #[link_name = "?staticHint@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_staticHint: *mut nsIAtom; - #[link_name = "?statusbar@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_statusbar: *mut nsIAtom; - #[link_name = "?statustext@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_statustext: *mut nsIAtom; - #[link_name = "?step@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_step: *mut nsIAtom; - #[link_name = "?stop@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stop: *mut nsIAtom; - #[link_name = "?stretch@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stretch: *mut nsIAtom; - #[link_name = "?strike@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_strike: *mut nsIAtom; - #[link_name = "?string@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_string: *mut nsIAtom; - #[link_name = "?stringLength@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stringLength: *mut nsIAtom; - #[link_name = "?stripSpace@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stripSpace: *mut nsIAtom; - #[link_name = "?strong@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_strong: *mut nsIAtom; - #[link_name = "?style@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_style: *mut nsIAtom; - #[link_name = "?stylesheet@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stylesheet: *mut nsIAtom; - #[link_name = "?stylesheetPrefix@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stylesheetPrefix: *mut nsIAtom; - #[link_name = "?subject@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_subject: *mut nsIAtom; - #[link_name = "?submit@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_submit: *mut nsIAtom; - #[link_name = "?substate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_substate: *mut nsIAtom; - #[link_name = "?substring@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_substring: *mut nsIAtom; - #[link_name = "?substringAfter@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_substringAfter: *mut nsIAtom; - #[link_name = "?substringBefore@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_substringBefore: *mut nsIAtom; - #[link_name = "?sub@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sub: *mut nsIAtom; - #[link_name = "?sum@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sum: *mut nsIAtom; - #[link_name = "?sup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sup: *mut nsIAtom; - #[link_name = "?summary@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_summary: *mut nsIAtom; - #[link_name = "?_switch@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__switch: *mut nsIAtom; - #[link_name = "?systemProperty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_systemProperty: *mut nsIAtom; - #[link_name = "?tab@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tab: *mut nsIAtom; - #[link_name = "?tabbox@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tabbox: *mut nsIAtom; - #[link_name = "?tabindex@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tabindex: *mut nsIAtom; - #[link_name = "?table@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_table: *mut nsIAtom; - #[link_name = "?tabpanel@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tabpanel: *mut nsIAtom; - #[link_name = "?tabpanels@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tabpanels: *mut nsIAtom; - #[link_name = "?tag@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tag: *mut nsIAtom; - #[link_name = "?target@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_target: *mut nsIAtom; - #[link_name = "?targets@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_targets: *mut nsIAtom; - #[link_name = "?tbody@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tbody: *mut nsIAtom; - #[link_name = "?td@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_td: *mut nsIAtom; - #[link_name = "?_template@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__template: *mut nsIAtom; - #[link_name = "?text_decoration@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_text_decoration: *mut nsIAtom; - #[link_name = "?terminate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_terminate: *mut nsIAtom; - #[link_name = "?term@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_term: *mut nsIAtom; - #[link_name = "?test@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_test: *mut nsIAtom; - #[link_name = "?text@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_text: *mut nsIAtom; - #[link_name = "?textAlign@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_textAlign: *mut nsIAtom; - #[link_name = "?textarea@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_textarea: *mut nsIAtom; - #[link_name = "?textbox@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_textbox: *mut nsIAtom; - #[link_name = "?textnode@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_textnode: *mut nsIAtom; - #[link_name = "?textNodeDirectionalityMap@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_textNodeDirectionalityMap: *mut nsIAtom; - #[link_name = "?tfoot@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tfoot: *mut nsIAtom; - #[link_name = "?th@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_th: *mut nsIAtom; - #[link_name = "?thead@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_thead: *mut nsIAtom; - #[link_name = "?thumb@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_thumb: *mut nsIAtom; - #[link_name = "?time@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_time: *mut nsIAtom; - #[link_name = "?title@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_title: *mut nsIAtom; - #[link_name = "?titlebar@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_titlebar: *mut nsIAtom; - #[link_name = "?titletip@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_titletip: *mut nsIAtom; - #[link_name = "?toggled@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_toggled: *mut nsIAtom; - #[link_name = "?token@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_token: *mut nsIAtom; - #[link_name = "?tokenize@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tokenize: *mut nsIAtom; - #[link_name = "?toolbar@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_toolbar: *mut nsIAtom; - #[link_name = "?toolbarbutton@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_toolbarbutton: *mut nsIAtom; - #[link_name = "?toolbaritem@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_toolbaritem: *mut nsIAtom; - #[link_name = "?toolbox@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_toolbox: *mut nsIAtom; - #[link_name = "?tooltip@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tooltip: *mut nsIAtom; - #[link_name = "?tooltiptext@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tooltiptext: *mut nsIAtom; - #[link_name = "?top@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_top: *mut nsIAtom; - #[link_name = "?topleft@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_topleft: *mut nsIAtom; - #[link_name = "?topmargin@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_topmargin: *mut nsIAtom; - #[link_name = "?toppadding@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_toppadding: *mut nsIAtom; - #[link_name = "?topright@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_topright: *mut nsIAtom; - #[link_name = "?tr@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tr: *mut nsIAtom; - #[link_name = "?track@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_track: *mut nsIAtom; - #[link_name = "?trad_chinese_formal@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_trad_chinese_formal: *mut nsIAtom; - #[link_name = "?trad_chinese_informal@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_trad_chinese_informal: *mut nsIAtom; - #[link_name = "?trailing@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_trailing: *mut nsIAtom; - #[link_name = "?transform@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_transform: *mut nsIAtom; - #[link_name = "?transform_3d@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_transform_3d: *mut nsIAtom; - #[link_name = "?transformiix@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_transformiix: *mut nsIAtom; - #[link_name = "?translate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_translate: *mut nsIAtom; - #[link_name = "?transparent@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_transparent: *mut nsIAtom; - #[link_name = "?tree@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tree: *mut nsIAtom; - #[link_name = "?treecell@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_treecell: *mut nsIAtom; - #[link_name = "?treechildren@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_treechildren: *mut nsIAtom; - #[link_name = "?treecol@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_treecol: *mut nsIAtom; - #[link_name = "?treecolpicker@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_treecolpicker: *mut nsIAtom; - #[link_name = "?treecols@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_treecols: *mut nsIAtom; - #[link_name = "?treeitem@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_treeitem: *mut nsIAtom; - #[link_name = "?treerow@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_treerow: *mut nsIAtom; - #[link_name = "?treeseparator@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_treeseparator: *mut nsIAtom; - #[link_name = "?triple@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_triple: *mut nsIAtom; - #[link_name = "?_true@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__true: *mut nsIAtom; - #[link_name = "?tt@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tt: *mut nsIAtom; - #[link_name = "?tty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tty: *mut nsIAtom; - #[link_name = "?tv@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tv: *mut nsIAtom; - #[link_name = "?type@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_type: *mut nsIAtom; - #[link_name = "?typemustmatch@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_typemustmatch: *mut nsIAtom; - #[link_name = "?u@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_u: *mut nsIAtom; - #[link_name = "?ul@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ul: *mut nsIAtom; - #[link_name = "?underflow@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_underflow: *mut nsIAtom; - #[link_name = "?undetermined@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_undetermined: *mut nsIAtom; - #[link_name = "?unload@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_unload: *mut nsIAtom; - #[link_name = "?unparsedEntityUri@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_unparsedEntityUri: *mut nsIAtom; - #[link_name = "?upperAlpha@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_upperAlpha: *mut nsIAtom; - #[link_name = "?upperFirst@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_upperFirst: *mut nsIAtom; - #[link_name = "?upperRoman@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_upperRoman: *mut nsIAtom; - #[link_name = "?uri@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_uri: *mut nsIAtom; - #[link_name = "?use@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_use: *mut nsIAtom; - #[link_name = "?useAttributeSets@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_useAttributeSets: *mut nsIAtom; - #[link_name = "?usemap@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_usemap: *mut nsIAtom; - #[link_name = "?user_scalable@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_user_scalable: *mut nsIAtom; - #[link_name = "?userInput@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_userInput: *mut nsIAtom; - #[link_name = "?validate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_validate: *mut nsIAtom; - #[link_name = "?valign@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_valign: *mut nsIAtom; - #[link_name = "?value@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_value: *mut nsIAtom; - #[link_name = "?values@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_values: *mut nsIAtom; - #[link_name = "?valueOf@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_valueOf: *mut nsIAtom; - #[link_name = "?valuetype@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_valuetype: *mut nsIAtom; - #[link_name = "?var@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_var: *mut nsIAtom; - #[link_name = "?variable@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_variable: *mut nsIAtom; - #[link_name = "?vbox@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_vbox: *mut nsIAtom; - #[link_name = "?vcard_name@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_vcard_name: *mut nsIAtom; - #[link_name = "?vendor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_vendor: *mut nsIAtom; - #[link_name = "?vendorUrl@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_vendorUrl: *mut nsIAtom; - #[link_name = "?version@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_version: *mut nsIAtom; - #[link_name = "?vert@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_vert: *mut nsIAtom; - #[link_name = "?vertical@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_vertical: *mut nsIAtom; - #[link_name = "?audio@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_audio: *mut nsIAtom; - #[link_name = "?video@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_video: *mut nsIAtom; - #[link_name = "?videocontrols@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_videocontrols: *mut nsIAtom; - #[link_name = "?viewport@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_viewport: *mut nsIAtom; - #[link_name = "?viewport_height@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_viewport_height: *mut nsIAtom; - #[link_name = "?viewport_initial_scale@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_viewport_initial_scale: *mut nsIAtom; - #[link_name = "?viewport_maximum_scale@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_viewport_maximum_scale: *mut nsIAtom; - #[link_name = "?viewport_minimum_scale@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_viewport_minimum_scale: *mut nsIAtom; - #[link_name = "?viewport_user_scalable@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_viewport_user_scalable: *mut nsIAtom; - #[link_name = "?viewport_width@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_viewport_width: *mut nsIAtom; - #[link_name = "?visibility@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_visibility: *mut nsIAtom; - #[link_name = "?visuallyselected@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_visuallyselected: *mut nsIAtom; - #[link_name = "?vlink@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_vlink: *mut nsIAtom; - #[link_name = "?vspace@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_vspace: *mut nsIAtom; - #[link_name = "?wbr@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_wbr: *mut nsIAtom; - #[link_name = "?webkitdirectory@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_webkitdirectory: *mut nsIAtom; - #[link_name = "?when@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_when: *mut nsIAtom; - #[link_name = "?where@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_where: *mut nsIAtom; - #[link_name = "?widget@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_widget: *mut nsIAtom; - #[link_name = "?width@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_width: *mut nsIAtom; - #[link_name = "?willChange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_willChange: *mut nsIAtom; - #[link_name = "?window@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_window: *mut nsIAtom; - #[link_name = "?headerWindowTarget@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_headerWindowTarget: *mut nsIAtom; - #[link_name = "?windowtype@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_windowtype: *mut nsIAtom; - #[link_name = "?withParam@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_withParam: *mut nsIAtom; - #[link_name = "?wizard@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_wizard: *mut nsIAtom; - #[link_name = "?wrap@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_wrap: *mut nsIAtom; - #[link_name = "?headerDNSPrefetchControl@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_headerDNSPrefetchControl: *mut nsIAtom; - #[link_name = "?headerCSP@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_headerCSP: *mut nsIAtom; - #[link_name = "?headerCSPReportOnly@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_headerCSPReportOnly: *mut nsIAtom; - #[link_name = "?headerXFO@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_headerXFO: *mut nsIAtom; - #[link_name = "?x_western@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x_western: *mut nsIAtom; - #[link_name = "?xml@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xml: *mut nsIAtom; - #[link_name = "?xml_stylesheet@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xml_stylesheet: *mut nsIAtom; - #[link_name = "?xmlns@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xmlns: *mut nsIAtom; - #[link_name = "?xmp@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xmp: *mut nsIAtom; - #[link_name = "?xulcontentsgenerated@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xulcontentsgenerated: *mut nsIAtom; - #[link_name = "?yes@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_yes: *mut nsIAtom; - #[link_name = "?z_index@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_z_index: *mut nsIAtom; - #[link_name = "?zeroDigit@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_zeroDigit: *mut nsIAtom; - #[link_name = "?percentage@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_percentage: *mut nsIAtom; - #[link_name = "?A@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_A: *mut nsIAtom; - #[link_name = "?alignment_baseline@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_alignment_baseline: *mut nsIAtom; - #[link_name = "?amplitude@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_amplitude: *mut nsIAtom; - #[link_name = "?animate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_animate: *mut nsIAtom; - #[link_name = "?animateColor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_animateColor: *mut nsIAtom; - #[link_name = "?animateMotion@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_animateMotion: *mut nsIAtom; - #[link_name = "?animateTransform@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_animateTransform: *mut nsIAtom; - #[link_name = "?arithmetic@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_arithmetic: *mut nsIAtom; - #[link_name = "?atop@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_atop: *mut nsIAtom; - #[link_name = "?azimuth@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_azimuth: *mut nsIAtom; - #[link_name = "?B@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_B: *mut nsIAtom; - #[link_name = "?backgroundColor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_backgroundColor: *mut nsIAtom; - #[link_name = "?background_image@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_background_image: *mut nsIAtom; - #[link_name = "?baseFrequency@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_baseFrequency: *mut nsIAtom; - #[link_name = "?baseline_shift@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_baseline_shift: *mut nsIAtom; - #[link_name = "?bias@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_bias: *mut nsIAtom; - #[link_name = "?caption_side@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_caption_side: *mut nsIAtom; - #[link_name = "?clip_path@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_clip_path: *mut nsIAtom; - #[link_name = "?clip_rule@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_clip_rule: *mut nsIAtom; - #[link_name = "?clipPath@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_clipPath: *mut nsIAtom; - #[link_name = "?clipPathUnits@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_clipPathUnits: *mut nsIAtom; - #[link_name = "?cm@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cm: *mut nsIAtom; - #[link_name = "?colorBurn@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_colorBurn: *mut nsIAtom; - #[link_name = "?colorDodge@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_colorDodge: *mut nsIAtom; - #[link_name = "?colorInterpolation@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_colorInterpolation: *mut nsIAtom; - #[link_name = "?colorInterpolationFilters@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_colorInterpolationFilters: *mut nsIAtom; - #[link_name = "?colorProfile@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_colorProfile: *mut nsIAtom; - #[link_name = "?cursor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cursor: *mut nsIAtom; - #[link_name = "?cx@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cx: *mut nsIAtom; - #[link_name = "?cy@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cy: *mut nsIAtom; - #[link_name = "?d@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_d: *mut nsIAtom; - #[link_name = "?darken@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_darken: *mut nsIAtom; - #[link_name = "?defs@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_defs: *mut nsIAtom; - #[link_name = "?deg@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_deg: *mut nsIAtom; - #[link_name = "?desc@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_desc: *mut nsIAtom; - #[link_name = "?diffuseConstant@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_diffuseConstant: *mut nsIAtom; - #[link_name = "?dilate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dilate: *mut nsIAtom; - #[link_name = "?direction@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_direction: *mut nsIAtom; - #[link_name = "?disable@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_disable: *mut nsIAtom; - #[link_name = "?disc@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_disc: *mut nsIAtom; - #[link_name = "?discrete@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_discrete: *mut nsIAtom; - #[link_name = "?divisor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_divisor: *mut nsIAtom; - #[link_name = "?dominant_baseline@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dominant_baseline: *mut nsIAtom; - #[link_name = "?duplicate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_duplicate: *mut nsIAtom; - #[link_name = "?dx@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dx: *mut nsIAtom; - #[link_name = "?dy@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dy: *mut nsIAtom; - #[link_name = "?edgeMode@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_edgeMode: *mut nsIAtom; - #[link_name = "?ellipse@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ellipse: *mut nsIAtom; - #[link_name = "?elevation@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_elevation: *mut nsIAtom; - #[link_name = "?erode@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_erode: *mut nsIAtom; - #[link_name = "?ex@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ex: *mut nsIAtom; - #[link_name = "?exact@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_exact: *mut nsIAtom; - #[link_name = "?exclusion@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_exclusion: *mut nsIAtom; - #[link_name = "?exponent@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_exponent: *mut nsIAtom; - #[link_name = "?feBlend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feBlend: *mut nsIAtom; - #[link_name = "?feColorMatrix@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feColorMatrix: *mut nsIAtom; - #[link_name = "?feComponentTransfer@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feComponentTransfer: *mut nsIAtom; - #[link_name = "?feComposite@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feComposite: *mut nsIAtom; - #[link_name = "?feConvolveMatrix@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feConvolveMatrix: *mut nsIAtom; - #[link_name = "?feDiffuseLighting@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feDiffuseLighting: *mut nsIAtom; - #[link_name = "?feDisplacementMap@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feDisplacementMap: *mut nsIAtom; - #[link_name = "?feDistantLight@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feDistantLight: *mut nsIAtom; - #[link_name = "?feDropShadow@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feDropShadow: *mut nsIAtom; - #[link_name = "?feFlood@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feFlood: *mut nsIAtom; - #[link_name = "?feFuncA@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feFuncA: *mut nsIAtom; - #[link_name = "?feFuncB@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feFuncB: *mut nsIAtom; - #[link_name = "?feFuncG@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feFuncG: *mut nsIAtom; - #[link_name = "?feFuncR@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feFuncR: *mut nsIAtom; - #[link_name = "?feGaussianBlur@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feGaussianBlur: *mut nsIAtom; - #[link_name = "?feImage@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feImage: *mut nsIAtom; - #[link_name = "?feMerge@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feMerge: *mut nsIAtom; - #[link_name = "?feMergeNode@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feMergeNode: *mut nsIAtom; - #[link_name = "?feMorphology@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feMorphology: *mut nsIAtom; - #[link_name = "?feOffset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feOffset: *mut nsIAtom; - #[link_name = "?fePointLight@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fePointLight: *mut nsIAtom; - #[link_name = "?feSpecularLighting@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feSpecularLighting: *mut nsIAtom; - #[link_name = "?feSpotLight@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feSpotLight: *mut nsIAtom; - #[link_name = "?feTile@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feTile: *mut nsIAtom; - #[link_name = "?feTurbulence@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feTurbulence: *mut nsIAtom; - #[link_name = "?fill@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fill: *mut nsIAtom; - #[link_name = "?fill_opacity@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fill_opacity: *mut nsIAtom; - #[link_name = "?fill_rule@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fill_rule: *mut nsIAtom; - #[link_name = "?filter@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_filter: *mut nsIAtom; - #[link_name = "?filterUnits@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_filterUnits: *mut nsIAtom; - #[link_name = "?_float@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__float: *mut nsIAtom; - #[link_name = "?flood_color@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_flood_color: *mut nsIAtom; - #[link_name = "?flood_opacity@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_flood_opacity: *mut nsIAtom; - #[link_name = "?font_face@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_font_face: *mut nsIAtom; - #[link_name = "?font_face_format@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_font_face_format: *mut nsIAtom; - #[link_name = "?font_face_name@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_font_face_name: *mut nsIAtom; - #[link_name = "?font_face_src@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_font_face_src: *mut nsIAtom; - #[link_name = "?font_face_uri@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_font_face_uri: *mut nsIAtom; - #[link_name = "?font_family@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_font_family: *mut nsIAtom; - #[link_name = "?font_size@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_font_size: *mut nsIAtom; - #[link_name = "?font_size_adjust@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_font_size_adjust: *mut nsIAtom; - #[link_name = "?font_stretch@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_font_stretch: *mut nsIAtom; - #[link_name = "?font_style@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_font_style: *mut nsIAtom; - #[link_name = "?font_variant@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_font_variant: *mut nsIAtom; - #[link_name = "?foreignObject@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_foreignObject: *mut nsIAtom; - #[link_name = "?fractalNoise@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fractalNoise: *mut nsIAtom; - #[link_name = "?fr@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fr: *mut nsIAtom; - #[link_name = "?fx@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fx: *mut nsIAtom; - #[link_name = "?fy@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fy: *mut nsIAtom; - #[link_name = "?G@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_G: *mut nsIAtom; - #[link_name = "?g@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_g: *mut nsIAtom; - #[link_name = "?gamma@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_gamma: *mut nsIAtom; - #[link_name = "?generic_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_generic_: *mut nsIAtom; - #[link_name = "?glyphRef@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_glyphRef: *mut nsIAtom; - #[link_name = "?grad@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_grad: *mut nsIAtom; - #[link_name = "?gradientTransform@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_gradientTransform: *mut nsIAtom; - #[link_name = "?gradientUnits@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_gradientUnits: *mut nsIAtom; - #[link_name = "?hardLight@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_hardLight: *mut nsIAtom; - #[link_name = "?hue@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_hue: *mut nsIAtom; - #[link_name = "?hueRotate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_hueRotate: *mut nsIAtom; - #[link_name = "?identity@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_identity: *mut nsIAtom; - #[link_name = "?image_rendering@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_image_rendering: *mut nsIAtom; - #[link_name = "?in@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_in: *mut nsIAtom; - #[link_name = "?in2@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_in2: *mut nsIAtom; - #[link_name = "?intercept@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_intercept: *mut nsIAtom; - #[link_name = "?k1@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_k1: *mut nsIAtom; - #[link_name = "?k2@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_k2: *mut nsIAtom; - #[link_name = "?k3@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_k3: *mut nsIAtom; - #[link_name = "?k4@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_k4: *mut nsIAtom; - #[link_name = "?kernelMatrix@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_kernelMatrix: *mut nsIAtom; - #[link_name = "?kernelUnitLength@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_kernelUnitLength: *mut nsIAtom; - #[link_name = "?lengthAdjust@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lengthAdjust: *mut nsIAtom; - #[link_name = "?letter_spacing@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_letter_spacing: *mut nsIAtom; - #[link_name = "?lighten@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lighten: *mut nsIAtom; - #[link_name = "?lighting_color@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lighting_color: *mut nsIAtom; - #[link_name = "?limitingConeAngle@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_limitingConeAngle: *mut nsIAtom; - #[link_name = "?linear@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_linear: *mut nsIAtom; - #[link_name = "?linearGradient@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_linearGradient: *mut nsIAtom; - #[link_name = "?linearRGB@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_linearRGB: *mut nsIAtom; - #[link_name = "?list_style_type@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_list_style_type: *mut nsIAtom; - #[link_name = "?luminanceToAlpha@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_luminanceToAlpha: *mut nsIAtom; - #[link_name = "?luminosity@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_luminosity: *mut nsIAtom; - #[link_name = "?magnify@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_magnify: *mut nsIAtom; - #[link_name = "?marker@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_marker: *mut nsIAtom; - #[link_name = "?marker_end@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_marker_end: *mut nsIAtom; - #[link_name = "?marker_mid@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_marker_mid: *mut nsIAtom; - #[link_name = "?marker_start@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_marker_start: *mut nsIAtom; - #[link_name = "?markerHeight@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_markerHeight: *mut nsIAtom; - #[link_name = "?markerUnits@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_markerUnits: *mut nsIAtom; - #[link_name = "?markerWidth@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_markerWidth: *mut nsIAtom; - #[link_name = "?mask@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mask: *mut nsIAtom; - #[link_name = "?maskContentUnits@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_maskContentUnits: *mut nsIAtom; - #[link_name = "?mask_type@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mask_type: *mut nsIAtom; - #[link_name = "?maskUnits@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_maskUnits: *mut nsIAtom; - #[link_name = "?matrix@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_matrix: *mut nsIAtom; - #[link_name = "?metadata@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_metadata: *mut nsIAtom; - #[link_name = "?missingGlyph@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_missingGlyph: *mut nsIAtom; - #[link_name = "?mm@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mm: *mut nsIAtom; - #[link_name = "?mpath@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mpath: *mut nsIAtom; - #[link_name = "?noStitch@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_noStitch: *mut nsIAtom; - #[link_name = "?numOctaves@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_numOctaves: *mut nsIAtom; - #[link_name = "?multiply@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_multiply: *mut nsIAtom; - #[link_name = "?objectBoundingBox@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_objectBoundingBox: *mut nsIAtom; - #[link_name = "?offset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_offset: *mut nsIAtom; - #[link_name = "?onSVGLoad@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onSVGLoad: *mut nsIAtom; - #[link_name = "?onSVGResize@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onSVGResize: *mut nsIAtom; - #[link_name = "?onSVGScroll@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onSVGScroll: *mut nsIAtom; - #[link_name = "?onSVGUnload@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onSVGUnload: *mut nsIAtom; - #[link_name = "?onSVGZoom@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onSVGZoom: *mut nsIAtom; - #[link_name = "?onzoom@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onzoom: *mut nsIAtom; - #[link_name = "?opacity@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_opacity: *mut nsIAtom; - #[link_name = "?_operator@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__operator: *mut nsIAtom; - #[link_name = "?out@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_out: *mut nsIAtom; - #[link_name = "?over@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_over: *mut nsIAtom; - #[link_name = "?overridePreserveAspectRatio@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_overridePreserveAspectRatio: *mut nsIAtom; - #[link_name = "?pad@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pad: *mut nsIAtom; - #[link_name = "?path@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_path: *mut nsIAtom; - #[link_name = "?pathLength@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pathLength: *mut nsIAtom; - #[link_name = "?patternContentUnits@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_patternContentUnits: *mut nsIAtom; - #[link_name = "?patternTransform@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_patternTransform: *mut nsIAtom; - #[link_name = "?patternUnits@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_patternUnits: *mut nsIAtom; - #[link_name = "?pc@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pc: *mut nsIAtom; - #[link_name = "?pointer_events@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pointer_events: *mut nsIAtom; - #[link_name = "?points@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_points: *mut nsIAtom; - #[link_name = "?pointsAtX@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pointsAtX: *mut nsIAtom; - #[link_name = "?pointsAtY@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pointsAtY: *mut nsIAtom; - #[link_name = "?pointsAtZ@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pointsAtZ: *mut nsIAtom; - #[link_name = "?polyline@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_polyline: *mut nsIAtom; - #[link_name = "?preserveAlpha@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_preserveAlpha: *mut nsIAtom; - #[link_name = "?preserveAspectRatio@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_preserveAspectRatio: *mut nsIAtom; - #[link_name = "?primitiveUnits@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_primitiveUnits: *mut nsIAtom; - #[link_name = "?pt@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pt: *mut nsIAtom; - #[link_name = "?px@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_px: *mut nsIAtom; - #[link_name = "?R@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_R: *mut nsIAtom; - #[link_name = "?r@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_r: *mut nsIAtom; - #[link_name = "?rad@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rad: *mut nsIAtom; - #[link_name = "?radialGradient@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_radialGradient: *mut nsIAtom; - #[link_name = "?radius@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_radius: *mut nsIAtom; - #[link_name = "?reflect@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_reflect: *mut nsIAtom; - #[link_name = "?refX@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_refX: *mut nsIAtom; - #[link_name = "?refY@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_refY: *mut nsIAtom; - #[link_name = "?requiredExtensions@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_requiredExtensions: *mut nsIAtom; - #[link_name = "?requiredFeatures@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_requiredFeatures: *mut nsIAtom; - #[link_name = "?rotate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rotate: *mut nsIAtom; - #[link_name = "?rx@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rx: *mut nsIAtom; - #[link_name = "?ry@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ry: *mut nsIAtom; - #[link_name = "?saturate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_saturate: *mut nsIAtom; - #[link_name = "?saturation@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_saturation: *mut nsIAtom; - #[link_name = "?set@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_set: *mut nsIAtom; - #[link_name = "?seed@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_seed: *mut nsIAtom; - #[link_name = "?shape_rendering@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_shape_rendering: *mut nsIAtom; - #[link_name = "?skewX@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_skewX: *mut nsIAtom; - #[link_name = "?skewY@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_skewY: *mut nsIAtom; - #[link_name = "?slope@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_slope: *mut nsIAtom; - #[link_name = "?slot@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_slot: *mut nsIAtom; - #[link_name = "?softLight@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_softLight: *mut nsIAtom; - #[link_name = "?spacing@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_spacing: *mut nsIAtom; - #[link_name = "?spacingAndGlyphs@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_spacingAndGlyphs: *mut nsIAtom; - #[link_name = "?specularConstant@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_specularConstant: *mut nsIAtom; - #[link_name = "?specularExponent@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_specularExponent: *mut nsIAtom; - #[link_name = "?spreadMethod@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_spreadMethod: *mut nsIAtom; - #[link_name = "?sRGB@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sRGB: *mut nsIAtom; - #[link_name = "?startOffset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_startOffset: *mut nsIAtom; - #[link_name = "?stdDeviation@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stdDeviation: *mut nsIAtom; - #[link_name = "?stitch@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stitch: *mut nsIAtom; - #[link_name = "?stitchTiles@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stitchTiles: *mut nsIAtom; - #[link_name = "?stop_color@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stop_color: *mut nsIAtom; - #[link_name = "?stop_opacity@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stop_opacity: *mut nsIAtom; - #[link_name = "?stroke@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stroke: *mut nsIAtom; - #[link_name = "?stroke_dasharray@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stroke_dasharray: *mut nsIAtom; - #[link_name = "?stroke_dashoffset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stroke_dashoffset: *mut nsIAtom; - #[link_name = "?stroke_linecap@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stroke_linecap: *mut nsIAtom; - #[link_name = "?stroke_linejoin@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stroke_linejoin: *mut nsIAtom; - #[link_name = "?stroke_miterlimit@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stroke_miterlimit: *mut nsIAtom; - #[link_name = "?stroke_opacity@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stroke_opacity: *mut nsIAtom; - #[link_name = "?stroke_width@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stroke_width: *mut nsIAtom; - #[link_name = "?strokeWidth@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_strokeWidth: *mut nsIAtom; - #[link_name = "?surfaceScale@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_surfaceScale: *mut nsIAtom; - #[link_name = "?svg@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_svg: *mut nsIAtom; - #[link_name = "?svgContextPaint@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_svgContextPaint: *mut nsIAtom; - #[link_name = "?svgSwitch@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_svgSwitch: *mut nsIAtom; - #[link_name = "?symbol@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_symbol: *mut nsIAtom; - #[link_name = "?systemLanguage@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_systemLanguage: *mut nsIAtom; - #[link_name = "?tableValues@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tableValues: *mut nsIAtom; - #[link_name = "?targetX@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_targetX: *mut nsIAtom; - #[link_name = "?targetY@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_targetY: *mut nsIAtom; - #[link_name = "?text_anchor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_text_anchor: *mut nsIAtom; - #[link_name = "?text_rendering@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_text_rendering: *mut nsIAtom; - #[link_name = "?textLength@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_textLength: *mut nsIAtom; - #[link_name = "?textPath@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_textPath: *mut nsIAtom; - #[link_name = "?tref@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tref: *mut nsIAtom; - #[link_name = "?tspan@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tspan: *mut nsIAtom; - #[link_name = "?turbulence@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_turbulence: *mut nsIAtom; - #[link_name = "?unicode_bidi@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_unicode_bidi: *mut nsIAtom; - #[link_name = "?userSpaceOnUse@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_userSpaceOnUse: *mut nsIAtom; - #[link_name = "?view@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_view: *mut nsIAtom; - #[link_name = "?viewBox@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_viewBox: *mut nsIAtom; - #[link_name = "?viewTarget@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_viewTarget: *mut nsIAtom; - #[link_name = "?white_space@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_white_space: *mut nsIAtom; - #[link_name = "?word_spacing@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_word_spacing: *mut nsIAtom; - #[link_name = "?writing_mode@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_writing_mode: *mut nsIAtom; - #[link_name = "?x@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x: *mut nsIAtom; - #[link_name = "?x1@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x1: *mut nsIAtom; - #[link_name = "?x2@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x2: *mut nsIAtom; - #[link_name = "?xChannelSelector@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xChannelSelector: *mut nsIAtom; - #[link_name = "?xor_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xor_: *mut nsIAtom; - #[link_name = "?y@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_y: *mut nsIAtom; - #[link_name = "?y1@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_y1: *mut nsIAtom; - #[link_name = "?y2@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_y2: *mut nsIAtom; - #[link_name = "?yChannelSelector@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_yChannelSelector: *mut nsIAtom; - #[link_name = "?z@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_z: *mut nsIAtom; - #[link_name = "?zoomAndPan@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_zoomAndPan: *mut nsIAtom; - #[link_name = "?vector_effect@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_vector_effect: *mut nsIAtom; - #[link_name = "?vertical_align@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_vertical_align: *mut nsIAtom; - #[link_name = "?accumulate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_accumulate: *mut nsIAtom; - #[link_name = "?additive@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_additive: *mut nsIAtom; - #[link_name = "?attributeName@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_attributeName: *mut nsIAtom; - #[link_name = "?attributeType@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_attributeType: *mut nsIAtom; - #[link_name = "?auto_reverse@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_auto_reverse: *mut nsIAtom; - #[link_name = "?begin@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_begin: *mut nsIAtom; - #[link_name = "?beginEvent@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_beginEvent: *mut nsIAtom; - #[link_name = "?by@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_by: *mut nsIAtom; - #[link_name = "?calcMode@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_calcMode: *mut nsIAtom; - #[link_name = "?css@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_css: *mut nsIAtom; - #[link_name = "?dur@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_dur: *mut nsIAtom; - #[link_name = "?keyPoints@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_keyPoints: *mut nsIAtom; - #[link_name = "?keySplines@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_keySplines: *mut nsIAtom; - #[link_name = "?keyTimes@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_keyTimes: *mut nsIAtom; - #[link_name = "?mozAnimateMotionDummyAttr@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozAnimateMotionDummyAttr: *mut nsIAtom; - #[link_name = "?onbegin@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onbegin: *mut nsIAtom; - #[link_name = "?onbeginEvent@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onbeginEvent: *mut nsIAtom; - #[link_name = "?onend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onend: *mut nsIAtom; - #[link_name = "?onendEvent@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onendEvent: *mut nsIAtom; - #[link_name = "?onrepeat@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onrepeat: *mut nsIAtom; - #[link_name = "?onrepeatEvent@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onrepeatEvent: *mut nsIAtom; - #[link_name = "?repeatCount@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_repeatCount: *mut nsIAtom; - #[link_name = "?repeatDur@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_repeatDur: *mut nsIAtom; - #[link_name = "?repeatEvent@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_repeatEvent: *mut nsIAtom; - #[link_name = "?restart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_restart: *mut nsIAtom; - #[link_name = "?to@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_to: *mut nsIAtom; - #[link_name = "?XML@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_XML: *mut nsIAtom; - #[link_name = "?abs_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_abs_: *mut nsIAtom; - #[link_name = "?accent_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_accent_: *mut nsIAtom; - #[link_name = "?accentunder_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_accentunder_: *mut nsIAtom; - #[link_name = "?actiontype_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_actiontype_: *mut nsIAtom; - #[link_name = "?alignmentscope_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_alignmentscope_: *mut nsIAtom; - #[link_name = "?altimg_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_altimg_: *mut nsIAtom; - #[link_name = "?altimg_height_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_altimg_height_: *mut nsIAtom; - #[link_name = "?altimg_valign_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_altimg_valign_: *mut nsIAtom; - #[link_name = "?altimg_width_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_altimg_width_: *mut nsIAtom; - #[link_name = "?annotation_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_annotation_: *mut nsIAtom; - #[link_name = "?annotation_xml_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_annotation_xml_: *mut nsIAtom; - #[link_name = "?apply_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_apply_: *mut nsIAtom; - #[link_name = "?approx_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_approx_: *mut nsIAtom; - #[link_name = "?arccos_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_arccos_: *mut nsIAtom; - #[link_name = "?arccosh_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_arccosh_: *mut nsIAtom; - #[link_name = "?arccot_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_arccot_: *mut nsIAtom; - #[link_name = "?arccoth_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_arccoth_: *mut nsIAtom; - #[link_name = "?arccsc_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_arccsc_: *mut nsIAtom; - #[link_name = "?arccsch_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_arccsch_: *mut nsIAtom; - #[link_name = "?arcsec_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_arcsec_: *mut nsIAtom; - #[link_name = "?arcsech_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_arcsech_: *mut nsIAtom; - #[link_name = "?arcsin_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_arcsin_: *mut nsIAtom; - #[link_name = "?arcsinh_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_arcsinh_: *mut nsIAtom; - #[link_name = "?arctan_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_arctan_: *mut nsIAtom; - #[link_name = "?arctanh_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_arctanh_: *mut nsIAtom; - #[link_name = "?arg_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_arg_: *mut nsIAtom; - #[link_name = "?bevelled_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_bevelled_: *mut nsIAtom; - #[link_name = "?bind_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_bind_: *mut nsIAtom; - #[link_name = "?bvar_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_bvar_: *mut nsIAtom; - #[link_name = "?card_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_card_: *mut nsIAtom; - #[link_name = "?cartesianproduct_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cartesianproduct_: *mut nsIAtom; - #[link_name = "?cbytes_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cbytes_: *mut nsIAtom; - #[link_name = "?cd_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cd_: *mut nsIAtom; - #[link_name = "?cdgroup_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cdgroup_: *mut nsIAtom; - #[link_name = "?cerror_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cerror_: *mut nsIAtom; - #[link_name = "?charalign_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_charalign_: *mut nsIAtom; - #[link_name = "?ci_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ci_: *mut nsIAtom; - #[link_name = "?closure_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_closure_: *mut nsIAtom; - #[link_name = "?cn_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cn_: *mut nsIAtom; - #[link_name = "?codomain_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_codomain_: *mut nsIAtom; - #[link_name = "?columnalign_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_columnalign_: *mut nsIAtom; - #[link_name = "?columnalignment_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_columnalignment_: *mut nsIAtom; - #[link_name = "?columnlines_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_columnlines_: *mut nsIAtom; - #[link_name = "?columnspacing_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_columnspacing_: *mut nsIAtom; - #[link_name = "?columnspan_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_columnspan_: *mut nsIAtom; - #[link_name = "?columnwidth_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_columnwidth_: *mut nsIAtom; - #[link_name = "?complexes_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_complexes_: *mut nsIAtom; - #[link_name = "?compose_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_compose_: *mut nsIAtom; - #[link_name = "?condition_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_condition_: *mut nsIAtom; - #[link_name = "?conjugate_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_conjugate_: *mut nsIAtom; - #[link_name = "?cos_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cos_: *mut nsIAtom; - #[link_name = "?cosh_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cosh_: *mut nsIAtom; - #[link_name = "?cot_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cot_: *mut nsIAtom; - #[link_name = "?coth_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_coth_: *mut nsIAtom; - #[link_name = "?crossout_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_crossout_: *mut nsIAtom; - #[link_name = "?csc_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_csc_: *mut nsIAtom; - #[link_name = "?csch_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_csch_: *mut nsIAtom; - #[link_name = "?cs_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cs_: *mut nsIAtom; - #[link_name = "?csymbol_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_csymbol_: *mut nsIAtom; - #[link_name = "?curl_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_curl_: *mut nsIAtom; - #[link_name = "?decimalpoint_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_decimalpoint_: *mut nsIAtom; - #[link_name = "?definitionURL_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_definitionURL_: *mut nsIAtom; - #[link_name = "?degree_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_degree_: *mut nsIAtom; - #[link_name = "?denomalign_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_denomalign_: *mut nsIAtom; - #[link_name = "?depth_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_depth_: *mut nsIAtom; - #[link_name = "?determinant_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_determinant_: *mut nsIAtom; - #[link_name = "?diff_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_diff_: *mut nsIAtom; - #[link_name = "?displaystyle_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_displaystyle_: *mut nsIAtom; - #[link_name = "?divergence_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_divergence_: *mut nsIAtom; - #[link_name = "?divide_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_divide_: *mut nsIAtom; - #[link_name = "?domain_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_domain_: *mut nsIAtom; - #[link_name = "?domainofapplication_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_domainofapplication_: *mut nsIAtom; - #[link_name = "?edge_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_edge_: *mut nsIAtom; - #[link_name = "?el_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_el_: *mut nsIAtom; - #[link_name = "?emptyset_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_emptyset_: *mut nsIAtom; - #[link_name = "?eq_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_eq_: *mut nsIAtom; - #[link_name = "?equalcolumns_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_equalcolumns_: *mut nsIAtom; - #[link_name = "?equalrows_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_equalrows_: *mut nsIAtom; - #[link_name = "?equivalent_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_equivalent_: *mut nsIAtom; - #[link_name = "?eulergamma_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_eulergamma_: *mut nsIAtom; - #[link_name = "?exists_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_exists_: *mut nsIAtom; - #[link_name = "?exp_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_exp_: *mut nsIAtom; - #[link_name = "?exponentiale_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_exponentiale_: *mut nsIAtom; - #[link_name = "?factorial_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_factorial_: *mut nsIAtom; - #[link_name = "?factorof_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_factorof_: *mut nsIAtom; - #[link_name = "?fence_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fence_: *mut nsIAtom; - #[link_name = "?fn_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fn_: *mut nsIAtom; - #[link_name = "?fontfamily_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fontfamily_: *mut nsIAtom; - #[link_name = "?fontsize_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fontsize_: *mut nsIAtom; - #[link_name = "?fontstyle_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fontstyle_: *mut nsIAtom; - #[link_name = "?fontweight_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fontweight_: *mut nsIAtom; - #[link_name = "?forall_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_forall_: *mut nsIAtom; - #[link_name = "?framespacing_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_framespacing_: *mut nsIAtom; - #[link_name = "?gcd_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_gcd_: *mut nsIAtom; - #[link_name = "?geq_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_geq_: *mut nsIAtom; - #[link_name = "?groupalign_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_groupalign_: *mut nsIAtom; - #[link_name = "?gt_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_gt_: *mut nsIAtom; - #[link_name = "?ident_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ident_: *mut nsIAtom; - #[link_name = "?imaginaryi_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_imaginaryi_: *mut nsIAtom; - #[link_name = "?imaginary_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_imaginary_: *mut nsIAtom; - #[link_name = "?implies_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_implies_: *mut nsIAtom; - #[link_name = "?indentalignfirst_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_indentalignfirst_: *mut nsIAtom; - #[link_name = "?indentalign_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_indentalign_: *mut nsIAtom; - #[link_name = "?indentalignlast_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_indentalignlast_: *mut nsIAtom; - #[link_name = "?indentshiftfirst_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_indentshiftfirst_: *mut nsIAtom; - #[link_name = "?indentshift_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_indentshift_: *mut nsIAtom; - #[link_name = "?indenttarget_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_indenttarget_: *mut nsIAtom; - #[link_name = "?integers_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_integers_: *mut nsIAtom; - #[link_name = "?intersect_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_intersect_: *mut nsIAtom; - #[link_name = "?interval_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_interval_: *mut nsIAtom; - #[link_name = "?int_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_int_: *mut nsIAtom; - #[link_name = "?inverse_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_inverse_: *mut nsIAtom; - #[link_name = "?lambda_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lambda_: *mut nsIAtom; - #[link_name = "?laplacian_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_laplacian_: *mut nsIAtom; - #[link_name = "?largeop_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_largeop_: *mut nsIAtom; - #[link_name = "?lcm_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lcm_: *mut nsIAtom; - #[link_name = "?leq_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_leq_: *mut nsIAtom; - #[link_name = "?limit_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_limit_: *mut nsIAtom; - #[link_name = "?linebreak_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_linebreak_: *mut nsIAtom; - #[link_name = "?linebreakmultchar_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_linebreakmultchar_: *mut nsIAtom; - #[link_name = "?linebreakstyle_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_linebreakstyle_: *mut nsIAtom; - #[link_name = "?linethickness_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_linethickness_: *mut nsIAtom; - #[link_name = "?list_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_list_: *mut nsIAtom; - #[link_name = "?ln_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ln_: *mut nsIAtom; - #[link_name = "?location_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_location_: *mut nsIAtom; - #[link_name = "?logbase_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_logbase_: *mut nsIAtom; - #[link_name = "?log_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_log_: *mut nsIAtom; - #[link_name = "?longdivstyle_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_longdivstyle_: *mut nsIAtom; - #[link_name = "?lowlimit_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lowlimit_: *mut nsIAtom; - #[link_name = "?lquote_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lquote_: *mut nsIAtom; - #[link_name = "?lspace_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lspace_: *mut nsIAtom; - #[link_name = "?lt_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lt_: *mut nsIAtom; - #[link_name = "?maction_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_maction_: *mut nsIAtom; - #[link_name = "?maligngroup_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_maligngroup_: *mut nsIAtom; - #[link_name = "?malignmark_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_malignmark_: *mut nsIAtom; - #[link_name = "?mathbackground_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mathbackground_: *mut nsIAtom; - #[link_name = "?mathcolor_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mathcolor_: *mut nsIAtom; - #[link_name = "?mathsize_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mathsize_: *mut nsIAtom; - #[link_name = "?mathvariant_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mathvariant_: *mut nsIAtom; - #[link_name = "?matrixrow_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_matrixrow_: *mut nsIAtom; - #[link_name = "?maxsize_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_maxsize_: *mut nsIAtom; - #[link_name = "?mean_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mean_: *mut nsIAtom; - #[link_name = "?median_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_median_: *mut nsIAtom; - #[link_name = "?menclose_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_menclose_: *mut nsIAtom; - #[link_name = "?merror_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_merror_: *mut nsIAtom; - #[link_name = "?mfenced_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mfenced_: *mut nsIAtom; - #[link_name = "?mfrac_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mfrac_: *mut nsIAtom; - #[link_name = "?mglyph_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mglyph_: *mut nsIAtom; - #[link_name = "?mi_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mi_: *mut nsIAtom; - #[link_name = "?minlabelspacing_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_minlabelspacing_: *mut nsIAtom; - #[link_name = "?minsize_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_minsize_: *mut nsIAtom; - #[link_name = "?minus_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_minus_: *mut nsIAtom; - #[link_name = "?mlabeledtr_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mlabeledtr_: *mut nsIAtom; - #[link_name = "?mlongdiv_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mlongdiv_: *mut nsIAtom; - #[link_name = "?mmultiscripts_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mmultiscripts_: *mut nsIAtom; - #[link_name = "?mn_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mn_: *mut nsIAtom; - #[link_name = "?momentabout_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_momentabout_: *mut nsIAtom; - #[link_name = "?moment_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_moment_: *mut nsIAtom; - #[link_name = "?mo_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mo_: *mut nsIAtom; - #[link_name = "?movablelimits_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_movablelimits_: *mut nsIAtom; - #[link_name = "?mover_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mover_: *mut nsIAtom; - #[link_name = "?mpadded_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mpadded_: *mut nsIAtom; - #[link_name = "?mphantom_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mphantom_: *mut nsIAtom; - #[link_name = "?mprescripts_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mprescripts_: *mut nsIAtom; - #[link_name = "?mroot_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mroot_: *mut nsIAtom; - #[link_name = "?mrow_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mrow_: *mut nsIAtom; - #[link_name = "?mscarries_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mscarries_: *mut nsIAtom; - #[link_name = "?mscarry_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mscarry_: *mut nsIAtom; - #[link_name = "?msgroup_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_msgroup_: *mut nsIAtom; - #[link_name = "?msline_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_msline_: *mut nsIAtom; - #[link_name = "?ms_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ms_: *mut nsIAtom; - #[link_name = "?mspace_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mspace_: *mut nsIAtom; - #[link_name = "?msqrt_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_msqrt_: *mut nsIAtom; - #[link_name = "?msrow_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_msrow_: *mut nsIAtom; - #[link_name = "?mstack_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mstack_: *mut nsIAtom; - #[link_name = "?mstyle_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mstyle_: *mut nsIAtom; - #[link_name = "?msub_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_msub_: *mut nsIAtom; - #[link_name = "?msubsup_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_msubsup_: *mut nsIAtom; - #[link_name = "?msup_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_msup_: *mut nsIAtom; - #[link_name = "?mtable_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mtable_: *mut nsIAtom; - #[link_name = "?mtd_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mtd_: *mut nsIAtom; - #[link_name = "?mtext_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mtext_: *mut nsIAtom; - #[link_name = "?mtr_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mtr_: *mut nsIAtom; - #[link_name = "?munder_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_munder_: *mut nsIAtom; - #[link_name = "?munderover_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_munderover_: *mut nsIAtom; - #[link_name = "?naturalnumbers_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_naturalnumbers_: *mut nsIAtom; - #[link_name = "?neq_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_neq_: *mut nsIAtom; - #[link_name = "?notanumber_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_notanumber_: *mut nsIAtom; - #[link_name = "?notation_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_notation_: *mut nsIAtom; - #[link_name = "?note_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_note_: *mut nsIAtom; - #[link_name = "?notin_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_notin_: *mut nsIAtom; - #[link_name = "?notprsubset_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_notprsubset_: *mut nsIAtom; - #[link_name = "?notsubset_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_notsubset_: *mut nsIAtom; - #[link_name = "?numalign_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_numalign_: *mut nsIAtom; - #[link_name = "?other_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_other_: *mut nsIAtom; - #[link_name = "?outerproduct_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_outerproduct_: *mut nsIAtom; - #[link_name = "?partialdiff_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_partialdiff_: *mut nsIAtom; - #[link_name = "?piece_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_piece_: *mut nsIAtom; - #[link_name = "?piecewise_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_piecewise_: *mut nsIAtom; - #[link_name = "?pi_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pi_: *mut nsIAtom; - #[link_name = "?plus_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_plus_: *mut nsIAtom; - #[link_name = "?power_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_power_: *mut nsIAtom; - #[link_name = "?primes_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_primes_: *mut nsIAtom; - #[link_name = "?product_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_product_: *mut nsIAtom; - #[link_name = "?prsubset_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_prsubset_: *mut nsIAtom; - #[link_name = "?quotient_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_quotient_: *mut nsIAtom; - #[link_name = "?rationals_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rationals_: *mut nsIAtom; - #[link_name = "?real_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_real_: *mut nsIAtom; - #[link_name = "?reals_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_reals_: *mut nsIAtom; - #[link_name = "?reln_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_reln_: *mut nsIAtom; - #[link_name = "?root_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_root_: *mut nsIAtom; - #[link_name = "?rowalign_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rowalign_: *mut nsIAtom; - #[link_name = "?rowlines_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rowlines_: *mut nsIAtom; - #[link_name = "?rowspacing_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rowspacing_: *mut nsIAtom; - #[link_name = "?rquote_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rquote_: *mut nsIAtom; - #[link_name = "?rspace_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rspace_: *mut nsIAtom; - #[link_name = "?scalarproduct_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scalarproduct_: *mut nsIAtom; - #[link_name = "?schemaLocation_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_schemaLocation_: *mut nsIAtom; - #[link_name = "?scriptlevel_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scriptlevel_: *mut nsIAtom; - #[link_name = "?scriptminsize_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scriptminsize_: *mut nsIAtom; - #[link_name = "?scriptsizemultiplier_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scriptsizemultiplier_: *mut nsIAtom; - #[link_name = "?scriptsize_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scriptsize_: *mut nsIAtom; - #[link_name = "?sdev_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sdev_: *mut nsIAtom; - #[link_name = "?sech_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sech_: *mut nsIAtom; - #[link_name = "?sec_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sec_: *mut nsIAtom; - #[link_name = "?selection_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_selection_: *mut nsIAtom; - #[link_name = "?selector_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_selector_: *mut nsIAtom; - #[link_name = "?semantics_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_semantics_: *mut nsIAtom; - #[link_name = "?separator_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_separator_: *mut nsIAtom; - #[link_name = "?separators_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_separators_: *mut nsIAtom; - #[link_name = "?sep_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sep_: *mut nsIAtom; - #[link_name = "?setdiff_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_setdiff_: *mut nsIAtom; - #[link_name = "?set_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_set_: *mut nsIAtom; - #[link_name = "?share_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_share_: *mut nsIAtom; - #[link_name = "?shift_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_shift_: *mut nsIAtom; - #[link_name = "?side_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_side_: *mut nsIAtom; - #[link_name = "?sinh_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sinh_: *mut nsIAtom; - #[link_name = "?sin_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sin_: *mut nsIAtom; - #[link_name = "?stackalign_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stackalign_: *mut nsIAtom; - #[link_name = "?stretchy_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stretchy_: *mut nsIAtom; - #[link_name = "?subscriptshift_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_subscriptshift_: *mut nsIAtom; - #[link_name = "?subset_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_subset_: *mut nsIAtom; - #[link_name = "?superscriptshift_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_superscriptshift_: *mut nsIAtom; - #[link_name = "?symmetric_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_symmetric_: *mut nsIAtom; - #[link_name = "?tanh_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tanh_: *mut nsIAtom; - #[link_name = "?tan_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tan_: *mut nsIAtom; - #[link_name = "?tendsto_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tendsto_: *mut nsIAtom; - #[link_name = "?times_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_times_: *mut nsIAtom; - #[link_name = "?transpose_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_transpose_: *mut nsIAtom; - #[link_name = "?union_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_union_: *mut nsIAtom; - #[link_name = "?uplimit_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_uplimit_: *mut nsIAtom; - #[link_name = "?variance_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_variance_: *mut nsIAtom; - #[link_name = "?vectorproduct_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_vectorproduct_: *mut nsIAtom; - #[link_name = "?vector_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_vector_: *mut nsIAtom; - #[link_name = "?voffset_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_voffset_: *mut nsIAtom; - #[link_name = "?xref_@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xref_: *mut nsIAtom; - #[link_name = "?math@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_math: *mut nsIAtom; - #[link_name = "?avg@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_avg: *mut nsIAtom; - #[link_name = "?booleanFromString@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_booleanFromString: *mut nsIAtom; - #[link_name = "?countNonEmpty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_countNonEmpty: *mut nsIAtom; - #[link_name = "?daysFromDate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_daysFromDate: *mut nsIAtom; - #[link_name = "?init@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_init: *mut nsIAtom; - #[link_name = "?instance@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_instance: *mut nsIAtom; - #[link_name = "?months@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_months: *mut nsIAtom; - #[link_name = "?now@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_now: *mut nsIAtom; - #[link_name = "?seconds@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_seconds: *mut nsIAtom; - #[link_name = "?secondsFromDateTime@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_secondsFromDateTime: *mut nsIAtom; - #[link_name = "?onMozSwipeGestureMayStart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onMozSwipeGestureMayStart: *mut nsIAtom; - #[link_name = "?onMozSwipeGestureStart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onMozSwipeGestureStart: *mut nsIAtom; - #[link_name = "?onMozSwipeGestureUpdate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onMozSwipeGestureUpdate: *mut nsIAtom; - #[link_name = "?onMozSwipeGestureEnd@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onMozSwipeGestureEnd: *mut nsIAtom; - #[link_name = "?onMozSwipeGesture@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onMozSwipeGesture: *mut nsIAtom; - #[link_name = "?onMozMagnifyGestureStart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onMozMagnifyGestureStart: *mut nsIAtom; - #[link_name = "?onMozMagnifyGestureUpdate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onMozMagnifyGestureUpdate: *mut nsIAtom; - #[link_name = "?onMozMagnifyGesture@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onMozMagnifyGesture: *mut nsIAtom; - #[link_name = "?onMozRotateGestureStart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onMozRotateGestureStart: *mut nsIAtom; - #[link_name = "?onMozRotateGestureUpdate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onMozRotateGestureUpdate: *mut nsIAtom; - #[link_name = "?onMozRotateGesture@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onMozRotateGesture: *mut nsIAtom; - #[link_name = "?onMozTapGesture@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onMozTapGesture: *mut nsIAtom; - #[link_name = "?onMozPressTapGesture@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onMozPressTapGesture: *mut nsIAtom; - #[link_name = "?onMozEdgeUIStarted@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onMozEdgeUIStarted: *mut nsIAtom; - #[link_name = "?onMozEdgeUICanceled@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onMozEdgeUICanceled: *mut nsIAtom; - #[link_name = "?onMozEdgeUICompleted@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onMozEdgeUICompleted: *mut nsIAtom; - #[link_name = "?onpointerdown@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpointerdown: *mut nsIAtom; - #[link_name = "?onpointermove@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpointermove: *mut nsIAtom; - #[link_name = "?onpointerup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpointerup: *mut nsIAtom; - #[link_name = "?onpointercancel@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpointercancel: *mut nsIAtom; - #[link_name = "?onpointerover@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpointerover: *mut nsIAtom; - #[link_name = "?onpointerout@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpointerout: *mut nsIAtom; - #[link_name = "?onpointerenter@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpointerenter: *mut nsIAtom; - #[link_name = "?onpointerleave@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpointerleave: *mut nsIAtom; - #[link_name = "?ongotpointercapture@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ongotpointercapture: *mut nsIAtom; - #[link_name = "?onlostpointercapture@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onlostpointercapture: *mut nsIAtom; - #[link_name = "?ondevicemotion@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondevicemotion: *mut nsIAtom; - #[link_name = "?ondeviceorientation@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondeviceorientation: *mut nsIAtom; - #[link_name = "?onabsolutedeviceorientation@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onabsolutedeviceorientation: *mut nsIAtom; - #[link_name = "?ondeviceproximity@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondeviceproximity: *mut nsIAtom; - #[link_name = "?onmozorientationchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmozorientationchange: *mut nsIAtom; - #[link_name = "?onuserproximity@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onuserproximity: *mut nsIAtom; - #[link_name = "?ondevicelight@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondevicelight: *mut nsIAtom; - #[link_name = "?ondevicechange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondevicechange: *mut nsIAtom; - #[link_name = "?mozinputrangeignorepreventdefault@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozinputrangeignorepreventdefault: *mut nsIAtom; - #[link_name = "?moz_extension@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_moz_extension: *mut nsIAtom; - #[link_name = "?all_urlsPermission@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_all_urlsPermission: *mut nsIAtom; - #[link_name = "?clipboardRead@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_clipboardRead: *mut nsIAtom; - #[link_name = "?clipboardWrite@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_clipboardWrite: *mut nsIAtom; - #[link_name = "?debugger@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_debugger: *mut nsIAtom; - #[link_name = "?tabs@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tabs: *mut nsIAtom; - #[link_name = "?webRequestBlocking@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_webRequestBlocking: *mut nsIAtom; - #[link_name = "?http@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_http: *mut nsIAtom; - #[link_name = "?https@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_https: *mut nsIAtom; - #[link_name = "?proxy@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_proxy: *mut nsIAtom; - #[link_name = "?cdataTagName@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cdataTagName: *mut nsIAtom; - #[link_name = "?commentTagName@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_commentTagName: *mut nsIAtom; - #[link_name = "?documentNodeName@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_documentNodeName: *mut nsIAtom; - #[link_name = "?documentFragmentNodeName@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_documentFragmentNodeName: *mut nsIAtom; - #[link_name = "?documentTypeNodeName@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_documentTypeNodeName: *mut nsIAtom; - #[link_name = "?processingInstructionTagName@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_processingInstructionTagName: *mut nsIAtom; - #[link_name = "?textTagName@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_textTagName: *mut nsIAtom; - #[link_name = "?placeholderFrame@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_placeholderFrame: *mut nsIAtom; - #[link_name = "?onloadend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onloadend: *mut nsIAtom; - #[link_name = "?onloadstart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onloadstart: *mut nsIAtom; - #[link_name = "?onprogress@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onprogress: *mut nsIAtom; - #[link_name = "?onsuspend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onsuspend: *mut nsIAtom; - #[link_name = "?onemptied@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onemptied: *mut nsIAtom; - #[link_name = "?onstalled@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onstalled: *mut nsIAtom; - #[link_name = "?onplay@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onplay: *mut nsIAtom; - #[link_name = "?onpause@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onpause: *mut nsIAtom; - #[link_name = "?onloadedmetadata@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onloadedmetadata: *mut nsIAtom; - #[link_name = "?onloadeddata@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onloadeddata: *mut nsIAtom; - #[link_name = "?onwaiting@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onwaiting: *mut nsIAtom; - #[link_name = "?onplaying@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onplaying: *mut nsIAtom; - #[link_name = "?oncanplay@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncanplay: *mut nsIAtom; - #[link_name = "?oncanplaythrough@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncanplaythrough: *mut nsIAtom; - #[link_name = "?onseeking@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onseeking: *mut nsIAtom; - #[link_name = "?onseeked@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onseeked: *mut nsIAtom; - #[link_name = "?ontimeout@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ontimeout: *mut nsIAtom; - #[link_name = "?ontimeupdate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ontimeupdate: *mut nsIAtom; - #[link_name = "?onended@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onended: *mut nsIAtom; - #[link_name = "?onratechange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onratechange: *mut nsIAtom; - #[link_name = "?ondurationchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondurationchange: *mut nsIAtom; - #[link_name = "?onvolumechange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onvolumechange: *mut nsIAtom; - #[link_name = "?onaddtrack@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onaddtrack: *mut nsIAtom; - #[link_name = "?oncontrollerchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncontrollerchange: *mut nsIAtom; - #[link_name = "?oncuechange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_oncuechange: *mut nsIAtom; - #[link_name = "?onenter@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onenter: *mut nsIAtom; - #[link_name = "?onexit@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onexit: *mut nsIAtom; - #[link_name = "?onencrypted@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onencrypted: *mut nsIAtom; - #[link_name = "?encrypted@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_encrypted: *mut nsIAtom; - #[link_name = "?onwaitingforkey@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onwaitingforkey: *mut nsIAtom; - #[link_name = "?onkeystatuseschange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onkeystatuseschange: *mut nsIAtom; - #[link_name = "?onremovetrack@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onremovetrack: *mut nsIAtom; - #[link_name = "?loadstart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_loadstart: *mut nsIAtom; - #[link_name = "?suspend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_suspend: *mut nsIAtom; - #[link_name = "?emptied@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_emptied: *mut nsIAtom; - #[link_name = "?stalled@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stalled: *mut nsIAtom; - #[link_name = "?play@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_play: *mut nsIAtom; - #[link_name = "?pause@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pause: *mut nsIAtom; - #[link_name = "?loadedmetadata@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_loadedmetadata: *mut nsIAtom; - #[link_name = "?loadeddata@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_loadeddata: *mut nsIAtom; - #[link_name = "?waiting@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_waiting: *mut nsIAtom; - #[link_name = "?playing@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_playing: *mut nsIAtom; - #[link_name = "?seeking@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_seeking: *mut nsIAtom; - #[link_name = "?seeked@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_seeked: *mut nsIAtom; - #[link_name = "?timeupdate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_timeupdate: *mut nsIAtom; - #[link_name = "?ended@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ended: *mut nsIAtom; - #[link_name = "?canplay@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_canplay: *mut nsIAtom; - #[link_name = "?canplaythrough@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_canplaythrough: *mut nsIAtom; - #[link_name = "?ratechange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ratechange: *mut nsIAtom; - #[link_name = "?durationchange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_durationchange: *mut nsIAtom; - #[link_name = "?volumechange@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_volumechange: *mut nsIAtom; - #[link_name = "?ondataavailable@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ondataavailable: *mut nsIAtom; - #[link_name = "?onwarning@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onwarning: *mut nsIAtom; - #[link_name = "?onstart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onstart: *mut nsIAtom; - #[link_name = "?onstop@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onstop: *mut nsIAtom; - #[link_name = "?onphoto@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onphoto: *mut nsIAtom; - #[link_name = "?onactivestatechanged@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onactivestatechanged: *mut nsIAtom; - #[link_name = "?ongamepadbuttondown@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ongamepadbuttondown: *mut nsIAtom; - #[link_name = "?ongamepadbuttonup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ongamepadbuttonup: *mut nsIAtom; - #[link_name = "?ongamepadaxismove@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ongamepadaxismove: *mut nsIAtom; - #[link_name = "?ongamepadconnected@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ongamepadconnected: *mut nsIAtom; - #[link_name = "?ongamepaddisconnected@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ongamepaddisconnected: *mut nsIAtom; - #[link_name = "?afterPseudoProperty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_afterPseudoProperty: *mut nsIAtom; - #[link_name = "?animationsProperty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_animationsProperty: *mut nsIAtom; - #[link_name = "?animationsOfBeforeProperty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_animationsOfBeforeProperty: *mut nsIAtom; - #[link_name = "?animationsOfAfterProperty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_animationsOfAfterProperty: *mut nsIAtom; - #[link_name = "?animationEffectsProperty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_animationEffectsProperty: *mut nsIAtom; - #[link_name = "?animationEffectsForBeforeProperty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_animationEffectsForBeforeProperty: *mut nsIAtom; - #[link_name = "?animationEffectsForAfterProperty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_animationEffectsForAfterProperty: *mut nsIAtom; - #[link_name = "?beforePseudoProperty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_beforePseudoProperty: *mut nsIAtom; - #[link_name = "?cssPseudoElementBeforeProperty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cssPseudoElementBeforeProperty: *mut nsIAtom; - #[link_name = "?cssPseudoElementAfterProperty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cssPseudoElementAfterProperty: *mut nsIAtom; - #[link_name = "?transitionsProperty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_transitionsProperty: *mut nsIAtom; - #[link_name = "?transitionsOfBeforeProperty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_transitionsOfBeforeProperty: *mut nsIAtom; - #[link_name = "?transitionsOfAfterProperty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_transitionsOfAfterProperty: *mut nsIAtom; - #[link_name = "?genConInitializerProperty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_genConInitializerProperty: *mut nsIAtom; - #[link_name = "?labelMouseDownPtProperty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_labelMouseDownPtProperty: *mut nsIAtom; - #[link_name = "?lockedStyleStates@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lockedStyleStates: *mut nsIAtom; - #[link_name = "?apzCallbackTransform@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_apzCallbackTransform: *mut nsIAtom; - #[link_name = "?restylableAnonymousNode@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_restylableAnonymousNode: *mut nsIAtom; - #[link_name = "?paintRequestTime@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_paintRequestTime: *mut nsIAtom; - #[link_name = "?pseudoProperty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pseudoProperty: *mut nsIAtom; - #[link_name = "?manualNACProperty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_manualNACProperty: *mut nsIAtom; - #[link_name = "?Japanese@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_Japanese: *mut nsIAtom; - #[link_name = "?Chinese@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_Chinese: *mut nsIAtom; - #[link_name = "?Taiwanese@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_Taiwanese: *mut nsIAtom; - #[link_name = "?HongKongChinese@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_HongKongChinese: *mut nsIAtom; - #[link_name = "?Unicode@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_Unicode: *mut nsIAtom; - #[link_name = "?ko@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ko: *mut nsIAtom; - #[link_name = "?zh_cn@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_zh_cn: *mut nsIAtom; - #[link_name = "?zh_hk@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_zh_hk: *mut nsIAtom; - #[link_name = "?zh_tw@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_zh_tw: *mut nsIAtom; - #[link_name = "?x_cyrillic@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x_cyrillic: *mut nsIAtom; - #[link_name = "?he@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_he: *mut nsIAtom; - #[link_name = "?ar@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ar: *mut nsIAtom; - #[link_name = "?x_devanagari@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x_devanagari: *mut nsIAtom; - #[link_name = "?x_tamil@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x_tamil: *mut nsIAtom; - #[link_name = "?x_armn@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x_armn: *mut nsIAtom; - #[link_name = "?x_beng@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x_beng: *mut nsIAtom; - #[link_name = "?x_cans@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x_cans: *mut nsIAtom; - #[link_name = "?x_ethi@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x_ethi: *mut nsIAtom; - #[link_name = "?x_geor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x_geor: *mut nsIAtom; - #[link_name = "?x_gujr@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x_gujr: *mut nsIAtom; - #[link_name = "?x_guru@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x_guru: *mut nsIAtom; - #[link_name = "?x_khmr@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x_khmr: *mut nsIAtom; - #[link_name = "?x_knda@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x_knda: *mut nsIAtom; - #[link_name = "?x_mlym@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x_mlym: *mut nsIAtom; - #[link_name = "?x_orya@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x_orya: *mut nsIAtom; - #[link_name = "?x_sinh@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x_sinh: *mut nsIAtom; - #[link_name = "?x_telu@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x_telu: *mut nsIAtom; - #[link_name = "?x_tibt@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x_tibt: *mut nsIAtom; - #[link_name = "?az@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_az: *mut nsIAtom; - #[link_name = "?ba@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ba: *mut nsIAtom; - #[link_name = "?crh@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_crh: *mut nsIAtom; - #[link_name = "?el@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_el: *mut nsIAtom; - #[link_name = "?ga@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ga: *mut nsIAtom; - #[link_name = "?nl@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nl: *mut nsIAtom; - #[link_name = "?x_math@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_x_math: *mut nsIAtom; - #[link_name = "?TypingTxnName@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_TypingTxnName: *mut nsIAtom; - #[link_name = "?IMETxnName@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_IMETxnName: *mut nsIAtom; - #[link_name = "?DeleteTxnName@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_DeleteTxnName: *mut nsIAtom; - #[link_name = "?serif@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_serif: *mut nsIAtom; - #[link_name = "?sans_serif@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_sans_serif: *mut nsIAtom; - #[link_name = "?cursive@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cursive: *mut nsIAtom; - #[link_name = "?fantasy@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fantasy: *mut nsIAtom; - #[link_name = "?monospace@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_monospace: *mut nsIAtom; - #[link_name = "?mozfixed@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mozfixed: *mut nsIAtom; - #[link_name = "?Remote@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_Remote: *mut nsIAtom; - #[link_name = "?RemoteId@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_RemoteId: *mut nsIAtom; - #[link_name = "?RemoteType@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_RemoteType: *mut nsIAtom; - #[link_name = "?DisplayPort@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_DisplayPort: *mut nsIAtom; - #[link_name = "?DisplayPortMargins@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_DisplayPortMargins: *mut nsIAtom; - #[link_name = "?DisplayPortBase@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_DisplayPortBase: *mut nsIAtom; - #[link_name = "?AsyncScrollLayerCreationFailed@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_AsyncScrollLayerCreationFailed: *mut nsIAtom; - #[link_name = "?forcemessagemanager@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_forcemessagemanager: *mut nsIAtom; - #[link_name = "?isPreloadBrowser@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_isPreloadBrowser: *mut nsIAtom; - #[link_name = "?color_picker_available@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_color_picker_available: *mut nsIAtom; - #[link_name = "?scrollbar_start_backward@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scrollbar_start_backward: *mut nsIAtom; - #[link_name = "?scrollbar_start_forward@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scrollbar_start_forward: *mut nsIAtom; - #[link_name = "?scrollbar_end_backward@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scrollbar_end_backward: *mut nsIAtom; - #[link_name = "?scrollbar_end_forward@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scrollbar_end_forward: *mut nsIAtom; - #[link_name = "?scrollbar_thumb_proportional@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scrollbar_thumb_proportional: *mut nsIAtom; - #[link_name = "?overlay_scrollbars@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_overlay_scrollbars: *mut nsIAtom; - #[link_name = "?windows_accent_color_in_titlebar@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_windows_accent_color_in_titlebar: *mut nsIAtom; - #[link_name = "?windows_default_theme@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_windows_default_theme: *mut nsIAtom; - #[link_name = "?mac_graphite_theme@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mac_graphite_theme: *mut nsIAtom; - #[link_name = "?mac_yosemite_theme@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mac_yosemite_theme: *mut nsIAtom; - #[link_name = "?windows_compositor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_windows_compositor: *mut nsIAtom; - #[link_name = "?windows_glass@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_windows_glass: *mut nsIAtom; - #[link_name = "?touch_enabled@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_touch_enabled: *mut nsIAtom; - #[link_name = "?menubar_drag@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_menubar_drag: *mut nsIAtom; - #[link_name = "?swipe_animation_enabled@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_swipe_animation_enabled: *mut nsIAtom; - #[link_name = "?physical_home_button@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_physical_home_button: *mut nsIAtom; - #[link_name = "?windows_classic@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_windows_classic: *mut nsIAtom; - #[link_name = "?windows_theme_aero@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_windows_theme_aero: *mut nsIAtom; - #[link_name = "?windows_theme_aero_lite@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_windows_theme_aero_lite: *mut nsIAtom; - #[link_name = "?windows_theme_luna_blue@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_windows_theme_luna_blue: *mut nsIAtom; - #[link_name = "?windows_theme_luna_olive@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_windows_theme_luna_olive: *mut nsIAtom; - #[link_name = "?windows_theme_luna_silver@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_windows_theme_luna_silver: *mut nsIAtom; - #[link_name = "?windows_theme_royale@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_windows_theme_royale: *mut nsIAtom; - #[link_name = "?windows_theme_zune@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_windows_theme_zune: *mut nsIAtom; - #[link_name = "?windows_theme_generic@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_windows_theme_generic: *mut nsIAtom; - #[link_name = "?_moz_color_picker_available@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_color_picker_available: *mut nsIAtom; - #[link_name = "?_moz_scrollbar_start_backward@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_scrollbar_start_backward: *mut nsIAtom; - #[link_name = "?_moz_scrollbar_start_forward@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_scrollbar_start_forward: *mut nsIAtom; - #[link_name = "?_moz_scrollbar_end_backward@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_scrollbar_end_backward: *mut nsIAtom; - #[link_name = "?_moz_scrollbar_end_forward@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_scrollbar_end_forward: *mut nsIAtom; - #[link_name = "?_moz_scrollbar_thumb_proportional@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_scrollbar_thumb_proportional: *mut nsIAtom; - #[link_name = "?_moz_overlay_scrollbars@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_overlay_scrollbars: *mut nsIAtom; - #[link_name = "?_moz_windows_accent_color_in_titlebar@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_windows_accent_color_in_titlebar: *mut nsIAtom; - #[link_name = "?_moz_windows_default_theme@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_windows_default_theme: *mut nsIAtom; - #[link_name = "?_moz_mac_graphite_theme@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_mac_graphite_theme: *mut nsIAtom; - #[link_name = "?_moz_mac_yosemite_theme@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_mac_yosemite_theme: *mut nsIAtom; - #[link_name = "?_moz_windows_compositor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_windows_compositor: *mut nsIAtom; - #[link_name = "?_moz_windows_classic@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_windows_classic: *mut nsIAtom; - #[link_name = "?_moz_windows_glass@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_windows_glass: *mut nsIAtom; - #[link_name = "?_moz_windows_theme@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_windows_theme: *mut nsIAtom; - #[link_name = "?_moz_os_version@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_os_version: *mut nsIAtom; - #[link_name = "?_moz_touch_enabled@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_touch_enabled: *mut nsIAtom; - #[link_name = "?_moz_menubar_drag@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_menubar_drag: *mut nsIAtom; - #[link_name = "?_moz_device_pixel_ratio@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_device_pixel_ratio: *mut nsIAtom; - #[link_name = "?_moz_device_orientation@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_device_orientation: *mut nsIAtom; - #[link_name = "?_moz_is_resource_document@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_is_resource_document: *mut nsIAtom; - #[link_name = "?_moz_swipe_animation_enabled@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_swipe_animation_enabled: *mut nsIAtom; - #[link_name = "?_moz_physical_home_button@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__moz_physical_home_button: *mut nsIAtom; - #[link_name = "?Back@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_Back: *mut nsIAtom; - #[link_name = "?Forward@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_Forward: *mut nsIAtom; - #[link_name = "?Reload@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_Reload: *mut nsIAtom; - #[link_name = "?Stop@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_Stop: *mut nsIAtom; - #[link_name = "?Search@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_Search: *mut nsIAtom; - #[link_name = "?Bookmarks@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_Bookmarks: *mut nsIAtom; - #[link_name = "?Home@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_Home: *mut nsIAtom; - #[link_name = "?Clear@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_Clear: *mut nsIAtom; - #[link_name = "?VolumeUp@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_VolumeUp: *mut nsIAtom; - #[link_name = "?VolumeDown@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_VolumeDown: *mut nsIAtom; - #[link_name = "?NextTrack@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_NextTrack: *mut nsIAtom; - #[link_name = "?PreviousTrack@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_PreviousTrack: *mut nsIAtom; - #[link_name = "?MediaStop@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_MediaStop: *mut nsIAtom; - #[link_name = "?PlayPause@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_PlayPause: *mut nsIAtom; - #[link_name = "?Menu@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_Menu: *mut nsIAtom; - #[link_name = "?New@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_New: *mut nsIAtom; - #[link_name = "?Open@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_Open: *mut nsIAtom; - #[link_name = "?Close@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_Close: *mut nsIAtom; - #[link_name = "?Save@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_Save: *mut nsIAtom; - #[link_name = "?Find@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_Find: *mut nsIAtom; - #[link_name = "?Help@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_Help: *mut nsIAtom; - #[link_name = "?Print@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_Print: *mut nsIAtom; - #[link_name = "?SendMail@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_SendMail: *mut nsIAtom; - #[link_name = "?ForwardMail@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ForwardMail: *mut nsIAtom; - #[link_name = "?ReplyToMail@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ReplyToMail: *mut nsIAtom; - #[link_name = "?mouseWheel@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mouseWheel: *mut nsIAtom; - #[link_name = "?pixels@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pixels: *mut nsIAtom; - #[link_name = "?lines@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lines: *mut nsIAtom; - #[link_name = "?pages@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pages: *mut nsIAtom; - #[link_name = "?scrollbars@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_scrollbars: *mut nsIAtom; - #[link_name = "?other@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_other: *mut nsIAtom; - #[link_name = "?apz@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_apz: *mut nsIAtom; - #[link_name = "?restore@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_restore: *mut nsIAtom; - #[link_name = "?alert@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_alert: *mut nsIAtom; - #[link_name = "?alertdialog@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_alertdialog: *mut nsIAtom; - #[link_name = "?application@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_application: *mut nsIAtom; - #[link_name = "?aria_colcount@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_colcount: *mut nsIAtom; - #[link_name = "?aria_colindex@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_colindex: *mut nsIAtom; - #[link_name = "?aria_details@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_details: *mut nsIAtom; - #[link_name = "?aria_errormessage@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_errormessage: *mut nsIAtom; - #[link_name = "?aria_grabbed@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_grabbed: *mut nsIAtom; - #[link_name = "?aria_label@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_label: *mut nsIAtom; - #[link_name = "?aria_modal@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_modal: *mut nsIAtom; - #[link_name = "?aria_orientation@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_orientation: *mut nsIAtom; - #[link_name = "?aria_rowcount@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_rowcount: *mut nsIAtom; - #[link_name = "?aria_rowindex@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_rowindex: *mut nsIAtom; - #[link_name = "?aria_valuetext@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_valuetext: *mut nsIAtom; - #[link_name = "?auto_generated@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_auto_generated: *mut nsIAtom; - #[link_name = "?banner@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_banner: *mut nsIAtom; - #[link_name = "?checkable@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_checkable: *mut nsIAtom; - #[link_name = "?choices@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_choices: *mut nsIAtom; - #[link_name = "?columnheader@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_columnheader: *mut nsIAtom; - #[link_name = "?complementary@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_complementary: *mut nsIAtom; - #[link_name = "?containerAtomic@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_containerAtomic: *mut nsIAtom; - #[link_name = "?containerBusy@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_containerBusy: *mut nsIAtom; - #[link_name = "?containerLive@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_containerLive: *mut nsIAtom; - #[link_name = "?containerLiveRole@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_containerLiveRole: *mut nsIAtom; - #[link_name = "?containerRelevant@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_containerRelevant: *mut nsIAtom; - #[link_name = "?contentinfo@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_contentinfo: *mut nsIAtom; - #[link_name = "?cycles@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_cycles: *mut nsIAtom; - #[link_name = "?datatable@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_datatable: *mut nsIAtom; - #[link_name = "?eventFromInput@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_eventFromInput: *mut nsIAtom; - #[link_name = "?feed@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feed: *mut nsIAtom; - #[link_name = "?grammar@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_grammar: *mut nsIAtom; - #[link_name = "?gridcell@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_gridcell: *mut nsIAtom; - #[link_name = "?heading@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_heading: *mut nsIAtom; - #[link_name = "?hitregion@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_hitregion: *mut nsIAtom; - #[link_name = "?inlinevalue@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_inlinevalue: *mut nsIAtom; - #[link_name = "?invalid@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_invalid: *mut nsIAtom; - #[link_name = "?item@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_item: *mut nsIAtom; - #[link_name = "?itemset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_itemset: *mut nsIAtom; - #[link_name = "?lineNumber@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lineNumber: *mut nsIAtom; - #[link_name = "?linkedPanel@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_linkedPanel: *mut nsIAtom; - #[link_name = "?live@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_live: *mut nsIAtom; - #[link_name = "?menuitemcheckbox@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_menuitemcheckbox: *mut nsIAtom; - #[link_name = "?menuitemradio@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_menuitemradio: *mut nsIAtom; - #[link_name = "?mixed@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_mixed: *mut nsIAtom; - #[link_name = "?multiline@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_multiline: *mut nsIAtom; - #[link_name = "?navigation@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_navigation: *mut nsIAtom; - #[link_name = "?polite@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_polite: *mut nsIAtom; - #[link_name = "?posinset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_posinset: *mut nsIAtom; - #[link_name = "?presentation@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_presentation: *mut nsIAtom; - #[link_name = "?progressbar@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_progressbar: *mut nsIAtom; - #[link_name = "?region@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_region: *mut nsIAtom; - #[link_name = "?rowgroup@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rowgroup: *mut nsIAtom; - #[link_name = "?rowheader@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rowheader: *mut nsIAtom; - #[link_name = "?search@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_search: *mut nsIAtom; - #[link_name = "?searchbox@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_searchbox: *mut nsIAtom; - #[link_name = "?select1@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_select1: *mut nsIAtom; - #[link_name = "?setsize@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_setsize: *mut nsIAtom; - #[link_name = "?spelling@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_spelling: *mut nsIAtom; - #[link_name = "?spinbutton@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_spinbutton: *mut nsIAtom; - #[link_name = "?status@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_status: *mut nsIAtom; - #[link_name = "?tableCellIndex@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tableCellIndex: *mut nsIAtom; - #[link_name = "?tablist@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tablist: *mut nsIAtom; - #[link_name = "?textIndent@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_textIndent: *mut nsIAtom; - #[link_name = "?textInputType@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_textInputType: *mut nsIAtom; - #[link_name = "?textLineThroughColor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_textLineThroughColor: *mut nsIAtom; - #[link_name = "?textLineThroughStyle@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_textLineThroughStyle: *mut nsIAtom; - #[link_name = "?textPosition@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_textPosition: *mut nsIAtom; - #[link_name = "?textUnderlineColor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_textUnderlineColor: *mut nsIAtom; - #[link_name = "?textUnderlineStyle@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_textUnderlineStyle: *mut nsIAtom; - #[link_name = "?timer@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_timer: *mut nsIAtom; - #[link_name = "?toolbarname@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_toolbarname: *mut nsIAtom; - #[link_name = "?toolbarseparator@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_toolbarseparator: *mut nsIAtom; - #[link_name = "?toolbarspacer@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_toolbarspacer: *mut nsIAtom; - #[link_name = "?toolbarspring@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_toolbarspring: *mut nsIAtom; - #[link_name = "?treegrid@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_treegrid: *mut nsIAtom; - #[link_name = "?_undefined@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms__undefined: *mut nsIAtom; - #[link_name = "?xmlroles@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xmlroles: *mut nsIAtom; - #[link_name = "?close_fence@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_close_fence: *mut nsIAtom; - #[link_name = "?denominator@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_denominator: *mut nsIAtom; - #[link_name = "?numerator@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_numerator: *mut nsIAtom; - #[link_name = "?open_fence@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_open_fence: *mut nsIAtom; - #[link_name = "?overscript@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_overscript: *mut nsIAtom; - #[link_name = "?presubscript@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_presubscript: *mut nsIAtom; - #[link_name = "?presuperscript@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_presuperscript: *mut nsIAtom; - #[link_name = "?root_index@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_root_index: *mut nsIAtom; - #[link_name = "?subscript@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_subscript: *mut nsIAtom; - #[link_name = "?superscript@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_superscript: *mut nsIAtom; - #[link_name = "?underscript@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_underscript: *mut nsIAtom; - #[link_name = "?onaudiostart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onaudiostart: *mut nsIAtom; - #[link_name = "?onaudioend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onaudioend: *mut nsIAtom; - #[link_name = "?onsoundstart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onsoundstart: *mut nsIAtom; - #[link_name = "?onsoundend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onsoundend: *mut nsIAtom; - #[link_name = "?onspeechstart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onspeechstart: *mut nsIAtom; - #[link_name = "?onspeechend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onspeechend: *mut nsIAtom; - #[link_name = "?onresult@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onresult: *mut nsIAtom; - #[link_name = "?onnomatch@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onnomatch: *mut nsIAtom; - #[link_name = "?onresume@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onresume: *mut nsIAtom; - #[link_name = "?onmark@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmark: *mut nsIAtom; - #[link_name = "?onboundary@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onboundary: *mut nsIAtom; - #[link_name = "?usercontextid@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_usercontextid: *mut nsIAtom; - #[link_name = "?nsuri_xmlns@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nsuri_xmlns: *mut nsIAtom; - #[link_name = "?nsuri_xml@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nsuri_xml: *mut nsIAtom; - #[link_name = "?nsuri_xhtml@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nsuri_xhtml: *mut nsIAtom; - #[link_name = "?nsuri_xlink@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nsuri_xlink: *mut nsIAtom; - #[link_name = "?nsuri_xslt@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nsuri_xslt: *mut nsIAtom; - #[link_name = "?nsuri_xbl@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nsuri_xbl: *mut nsIAtom; - #[link_name = "?nsuri_mathml@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nsuri_mathml: *mut nsIAtom; - #[link_name = "?nsuri_rdf@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nsuri_rdf: *mut nsIAtom; - #[link_name = "?nsuri_xul@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nsuri_xul: *mut nsIAtom; - #[link_name = "?nsuri_svg@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_nsuri_svg: *mut nsIAtom; - #[link_name = "?onsourceopen@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onsourceopen: *mut nsIAtom; - #[link_name = "?onsourceended@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onsourceended: *mut nsIAtom; - #[link_name = "?onsourceclosed@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onsourceclosed: *mut nsIAtom; - #[link_name = "?onupdatestart@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onupdatestart: *mut nsIAtom; - #[link_name = "?onupdate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onupdate: *mut nsIAtom; - #[link_name = "?onupdateend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onupdateend: *mut nsIAtom; - #[link_name = "?onaddsourcebuffer@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onaddsourcebuffer: *mut nsIAtom; - #[link_name = "?onremovesourcebuffer@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onremovesourcebuffer: *mut nsIAtom; - #[link_name = "?xlink@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xlink: *mut nsIAtom; - #[link_name = "?xml_space@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xml_space: *mut nsIAtom; - #[link_name = "?xml_lang@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xml_lang: *mut nsIAtom; - #[link_name = "?xml_base@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xml_base: *mut nsIAtom; - #[link_name = "?aria_grab@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_grab: *mut nsIAtom; - #[link_name = "?aria_channel@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_channel: *mut nsIAtom; - #[link_name = "?aria_secret@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_secret: *mut nsIAtom; - #[link_name = "?aria_templateid@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_templateid: *mut nsIAtom; - #[link_name = "?aria_datatype@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_aria_datatype: *mut nsIAtom; - #[link_name = "?local@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_local: *mut nsIAtom; - #[link_name = "?xchannelselector@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xchannelselector: *mut nsIAtom; - #[link_name = "?ychannelselector@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_ychannelselector: *mut nsIAtom; - #[link_name = "?enable_background@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_enable_background: *mut nsIAtom; - #[link_name = "?calcmode@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_calcmode: *mut nsIAtom; - #[link_name = "?specularexponent@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_specularexponent: *mut nsIAtom; - #[link_name = "?specularconstant@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_specularconstant: *mut nsIAtom; - #[link_name = "?gradienttransform@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_gradienttransform: *mut nsIAtom; - #[link_name = "?gradientunits@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_gradientunits: *mut nsIAtom; - #[link_name = "?rendering_intent@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_rendering_intent: *mut nsIAtom; - #[link_name = "?stddeviation@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stddeviation: *mut nsIAtom; - #[link_name = "?basefrequency@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_basefrequency: *mut nsIAtom; - #[link_name = "?baseprofile@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_baseprofile: *mut nsIAtom; - #[link_name = "?baseProfile@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_baseProfile: *mut nsIAtom; - #[link_name = "?edgemode@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_edgemode: *mut nsIAtom; - #[link_name = "?repeatcount@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_repeatcount: *mut nsIAtom; - #[link_name = "?repeatdur@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_repeatdur: *mut nsIAtom; - #[link_name = "?spreadmethod@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_spreadmethod: *mut nsIAtom; - #[link_name = "?diffuseconstant@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_diffuseconstant: *mut nsIAtom; - #[link_name = "?surfacescale@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_surfacescale: *mut nsIAtom; - #[link_name = "?lengthadjust@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lengthadjust: *mut nsIAtom; - #[link_name = "?origin@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_origin: *mut nsIAtom; - #[link_name = "?targetx@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_targetx: *mut nsIAtom; - #[link_name = "?targety@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_targety: *mut nsIAtom; - #[link_name = "?pathlength@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pathlength: *mut nsIAtom; - #[link_name = "?definitionurl@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_definitionurl: *mut nsIAtom; - #[link_name = "?limitingconeangle@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_limitingconeangle: *mut nsIAtom; - #[link_name = "?markerheight@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_markerheight: *mut nsIAtom; - #[link_name = "?markerwidth@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_markerwidth: *mut nsIAtom; - #[link_name = "?maskunits@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_maskunits: *mut nsIAtom; - #[link_name = "?markerunits@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_markerunits: *mut nsIAtom; - #[link_name = "?maskcontentunits@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_maskcontentunits: *mut nsIAtom; - #[link_name = "?tablevalues@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_tablevalues: *mut nsIAtom; - #[link_name = "?primitiveunits@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_primitiveunits: *mut nsIAtom; - #[link_name = "?zoomandpan@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_zoomandpan: *mut nsIAtom; - #[link_name = "?kernelmatrix@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_kernelmatrix: *mut nsIAtom; - #[link_name = "?kerning@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_kerning: *mut nsIAtom; - #[link_name = "?kernelunitlength@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_kernelunitlength: *mut nsIAtom; - #[link_name = "?pointsatx@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pointsatx: *mut nsIAtom; - #[link_name = "?pointsaty@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pointsaty: *mut nsIAtom; - #[link_name = "?pointsatz@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_pointsatz: *mut nsIAtom; - #[link_name = "?xlink_href@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xlink_href: *mut nsIAtom; - #[link_name = "?xlink_title@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xlink_title: *mut nsIAtom; - #[link_name = "?xlink_role@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xlink_role: *mut nsIAtom; - #[link_name = "?xlink_arcrole@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xlink_arcrole: *mut nsIAtom; - #[link_name = "?arcrole@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_arcrole: *mut nsIAtom; - #[link_name = "?xmlns_xlink@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xmlns_xlink: *mut nsIAtom; - #[link_name = "?xlink_type@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xlink_type: *mut nsIAtom; - #[link_name = "?xlink_show@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xlink_show: *mut nsIAtom; - #[link_name = "?xlink_actuate@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_xlink_actuate: *mut nsIAtom; - #[link_name = "?color_rendering@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_color_rendering: *mut nsIAtom; - #[link_name = "?numoctaves@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_numoctaves: *mut nsIAtom; - #[link_name = "?onmousewheel@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_onmousewheel: *mut nsIAtom; - #[link_name = "?clippathunits@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_clippathunits: *mut nsIAtom; - #[link_name = "?glyph_orientation_vertical@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_glyph_orientation_vertical: *mut nsIAtom; - #[link_name = "?glyph_orientation_horizontal@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_glyph_orientation_horizontal: *mut nsIAtom; - #[link_name = "?glyphref@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_glyphref: *mut nsIAtom; - #[link_name = "?keypoints@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_keypoints: *mut nsIAtom; - #[link_name = "?attributename@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_attributename: *mut nsIAtom; - #[link_name = "?attributetype@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_attributetype: *mut nsIAtom; - #[link_name = "?startoffset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_startoffset: *mut nsIAtom; - #[link_name = "?keysplines@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_keysplines: *mut nsIAtom; - #[link_name = "?preservealpha@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_preservealpha: *mut nsIAtom; - #[link_name = "?preserveaspectratio@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_preserveaspectratio: *mut nsIAtom; - #[link_name = "?alttext@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_alttext: *mut nsIAtom; - #[link_name = "?filterunits@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_filterunits: *mut nsIAtom; - #[link_name = "?keytimes@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_keytimes: *mut nsIAtom; - #[link_name = "?patterntransform@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_patterntransform: *mut nsIAtom; - #[link_name = "?patternunits@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_patternunits: *mut nsIAtom; - #[link_name = "?patterncontentunits@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_patterncontentunits: *mut nsIAtom; - #[link_name = "?stitchtiles@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_stitchtiles: *mut nsIAtom; - #[link_name = "?systemlanguage@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_systemlanguage: *mut nsIAtom; - #[link_name = "?textlength@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_textlength: *mut nsIAtom; - #[link_name = "?requiredfeatures@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_requiredfeatures: *mut nsIAtom; - #[link_name = "?requiredextensions@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_requiredextensions: *mut nsIAtom; - #[link_name = "?viewtarget@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_viewtarget: *mut nsIAtom; - #[link_name = "?viewbox@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_viewbox: *mut nsIAtom; - #[link_name = "?refx@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_refx: *mut nsIAtom; - #[link_name = "?refy@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_refy: *mut nsIAtom; - #[link_name = "?fefunca@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fefunca: *mut nsIAtom; - #[link_name = "?fefuncb@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fefuncb: *mut nsIAtom; - #[link_name = "?feblend@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feblend: *mut nsIAtom; - #[link_name = "?feflood@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feflood: *mut nsIAtom; - #[link_name = "?feturbulence@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feturbulence: *mut nsIAtom; - #[link_name = "?femergenode@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_femergenode: *mut nsIAtom; - #[link_name = "?feimage@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feimage: *mut nsIAtom; - #[link_name = "?femerge@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_femerge: *mut nsIAtom; - #[link_name = "?fetile@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fetile: *mut nsIAtom; - #[link_name = "?fecomposite@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fecomposite: *mut nsIAtom; - #[link_name = "?altglyphdef@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_altglyphdef: *mut nsIAtom; - #[link_name = "?altGlyphDef@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_altGlyphDef: *mut nsIAtom; - #[link_name = "?fefuncg@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fefuncg: *mut nsIAtom; - #[link_name = "?fediffuselighting@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fediffuselighting: *mut nsIAtom; - #[link_name = "?fespecularlighting@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fespecularlighting: *mut nsIAtom; - #[link_name = "?altglyph@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_altglyph: *mut nsIAtom; - #[link_name = "?altGlyph@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_altGlyph: *mut nsIAtom; - #[link_name = "?clippath@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_clippath: *mut nsIAtom; - #[link_name = "?textpath@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_textpath: *mut nsIAtom; - #[link_name = "?altglyphitem@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_altglyphitem: *mut nsIAtom; - #[link_name = "?altGlyphItem@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_altGlyphItem: *mut nsIAtom; - #[link_name = "?animatetransform@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_animatetransform: *mut nsIAtom; - #[link_name = "?animatemotion@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_animatemotion: *mut nsIAtom; - #[link_name = "?fedisplacementmap@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fedisplacementmap: *mut nsIAtom; - #[link_name = "?animatecolor@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_animatecolor: *mut nsIAtom; - #[link_name = "?fefuncr@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fefuncr: *mut nsIAtom; - #[link_name = "?fecomponenttransfer@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fecomponenttransfer: *mut nsIAtom; - #[link_name = "?fegaussianblur@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fegaussianblur: *mut nsIAtom; - #[link_name = "?foreignobject@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_foreignobject: *mut nsIAtom; - #[link_name = "?feoffset@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feoffset: *mut nsIAtom; - #[link_name = "?fespotlight@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fespotlight: *mut nsIAtom; - #[link_name = "?fepointlight@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fepointlight: *mut nsIAtom; - #[link_name = "?fedistantlight@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fedistantlight: *mut nsIAtom; - #[link_name = "?lineargradient@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_lineargradient: *mut nsIAtom; - #[link_name = "?radialgradient@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_radialgradient: *mut nsIAtom; - #[link_name = "?fedropshadow@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fedropshadow: *mut nsIAtom; - #[link_name = "?fecolormatrix@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_fecolormatrix: *mut nsIAtom; - #[link_name = "?feconvolvematrix@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_feconvolvematrix: *mut nsIAtom; - #[link_name = "?femorphology@nsGkAtoms@@2PEAVnsIAtom@@EA"] - pub static nsGkAtoms_femorphology: *mut nsIAtom; + #[link_name = "?_empty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__empty: *mut nsAtom; + #[link_name = "?moz@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_moz: *mut nsAtom; + #[link_name = "?mozframetype@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozframetype: *mut nsAtom; + #[link_name = "?_moz_abspos@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_abspos: *mut nsAtom; + #[link_name = "?_moz_activated@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_activated: *mut nsAtom; + #[link_name = "?_moz_anonclass@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_anonclass: *mut nsAtom; + #[link_name = "?_moz_resizing@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_resizing: *mut nsAtom; + #[link_name = "?mozallowfullscreen@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozallowfullscreen: *mut nsAtom; + #[link_name = "?moztype@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_moztype: *mut nsAtom; + #[link_name = "?mozdirty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozdirty: *mut nsAtom; + #[link_name = "?mozdisallowselectionprint@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozdisallowselectionprint: *mut nsAtom; + #[link_name = "?mozdonotsend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozdonotsend: *mut nsAtom; + #[link_name = "?mozeditorbogusnode@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozeditorbogusnode: *mut nsAtom; + #[link_name = "?mozgeneratedcontentbefore@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozgeneratedcontentbefore: *mut nsAtom; + #[link_name = "?mozgeneratedcontentafter@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozgeneratedcontentafter: *mut nsAtom; + #[link_name = "?mozgeneratedcontentimage@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozgeneratedcontentimage: *mut nsAtom; + #[link_name = "?mozquote@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozquote: *mut nsAtom; + #[link_name = "?mozsignature@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozsignature: *mut nsAtom; + #[link_name = "?_moz_is_glyph@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_is_glyph: *mut nsAtom; + #[link_name = "?_moz_original_size@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_original_size: *mut nsAtom; + #[link_name = "?_moz_target@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_target: *mut nsAtom; + #[link_name = "?menuactive@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_menuactive: *mut nsAtom; + #[link_name = "?_poundDefault@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__poundDefault: *mut nsAtom; + #[link_name = "?_asterisk@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__asterisk: *mut nsAtom; + #[link_name = "?a@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_a: *mut nsAtom; + #[link_name = "?abbr@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_abbr: *mut nsAtom; + #[link_name = "?abort@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_abort: *mut nsAtom; + #[link_name = "?above@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_above: *mut nsAtom; + #[link_name = "?acceltext@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_acceltext: *mut nsAtom; + #[link_name = "?accept@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_accept: *mut nsAtom; + #[link_name = "?acceptcharset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_acceptcharset: *mut nsAtom; + #[link_name = "?accesskey@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_accesskey: *mut nsAtom; + #[link_name = "?acronym@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_acronym: *mut nsAtom; + #[link_name = "?action@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_action: *mut nsAtom; + #[link_name = "?active@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_active: *mut nsAtom; + #[link_name = "?activetitlebarcolor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_activetitlebarcolor: *mut nsAtom; + #[link_name = "?activateontab@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_activateontab: *mut nsAtom; + #[link_name = "?actuate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_actuate: *mut nsAtom; + #[link_name = "?address@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_address: *mut nsAtom; + #[link_name = "?after@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_after: *mut nsAtom; + #[link_name = "?after_end@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_after_end: *mut nsAtom; + #[link_name = "?after_start@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_after_start: *mut nsAtom; + #[link_name = "?align@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_align: *mut nsAtom; + #[link_name = "?alink@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_alink: *mut nsAtom; + #[link_name = "?all@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_all: *mut nsAtom; + #[link_name = "?allowdirs@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_allowdirs: *mut nsAtom; + #[link_name = "?allowevents@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_allowevents: *mut nsAtom; + #[link_name = "?allownegativeassertions@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_allownegativeassertions: *mut nsAtom; + #[link_name = "?allowforms@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_allowforms: *mut nsAtom; + #[link_name = "?allowfullscreen@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_allowfullscreen: *mut nsAtom; + #[link_name = "?allowmodals@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_allowmodals: *mut nsAtom; + #[link_name = "?alloworientationlock@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_alloworientationlock: *mut nsAtom; + #[link_name = "?allowpaymentrequest@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_allowpaymentrequest: *mut nsAtom; + #[link_name = "?allowpointerlock@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_allowpointerlock: *mut nsAtom; + #[link_name = "?allowpopupstoescapesandbox@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_allowpopupstoescapesandbox: *mut nsAtom; + #[link_name = "?allowpopups@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_allowpopups: *mut nsAtom; + #[link_name = "?allowpresentation@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_allowpresentation: *mut nsAtom; + #[link_name = "?allowsameorigin@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_allowsameorigin: *mut nsAtom; + #[link_name = "?allowscripts@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_allowscripts: *mut nsAtom; + #[link_name = "?allowtopnavigation@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_allowtopnavigation: *mut nsAtom; + #[link_name = "?allowuntrusted@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_allowuntrusted: *mut nsAtom; + #[link_name = "?alt@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_alt: *mut nsAtom; + #[link_name = "?alternate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_alternate: *mut nsAtom; + #[link_name = "?always@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_always: *mut nsAtom; + #[link_name = "?ancestor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ancestor: *mut nsAtom; + #[link_name = "?ancestorOrSelf@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ancestorOrSelf: *mut nsAtom; + #[link_name = "?anchor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_anchor: *mut nsAtom; + #[link_name = "?_and@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__and: *mut nsAtom; + #[link_name = "?animations@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_animations: *mut nsAtom; + #[link_name = "?anonid@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_anonid: *mut nsAtom; + #[link_name = "?anonlocation@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_anonlocation: *mut nsAtom; + #[link_name = "?any@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_any: *mut nsAtom; + #[link_name = "?applet@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_applet: *mut nsAtom; + #[link_name = "?applyImports@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_applyImports: *mut nsAtom; + #[link_name = "?applyTemplates@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_applyTemplates: *mut nsAtom; + #[link_name = "?archive@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_archive: *mut nsAtom; + #[link_name = "?area@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_area: *mut nsAtom; + #[link_name = "?aria_activedescendant@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_activedescendant: *mut nsAtom; + #[link_name = "?aria_atomic@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_atomic: *mut nsAtom; + #[link_name = "?aria_autocomplete@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_autocomplete: *mut nsAtom; + #[link_name = "?aria_busy@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_busy: *mut nsAtom; + #[link_name = "?aria_checked@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_checked: *mut nsAtom; + #[link_name = "?aria_controls@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_controls: *mut nsAtom; + #[link_name = "?aria_current@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_current: *mut nsAtom; + #[link_name = "?aria_describedby@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_describedby: *mut nsAtom; + #[link_name = "?aria_disabled@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_disabled: *mut nsAtom; + #[link_name = "?aria_dropeffect@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_dropeffect: *mut nsAtom; + #[link_name = "?aria_expanded@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_expanded: *mut nsAtom; + #[link_name = "?aria_flowto@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_flowto: *mut nsAtom; + #[link_name = "?aria_haspopup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_haspopup: *mut nsAtom; + #[link_name = "?aria_hidden@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_hidden: *mut nsAtom; + #[link_name = "?aria_invalid@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_invalid: *mut nsAtom; + #[link_name = "?aria_labelledby@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_labelledby: *mut nsAtom; + #[link_name = "?aria_level@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_level: *mut nsAtom; + #[link_name = "?aria_live@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_live: *mut nsAtom; + #[link_name = "?aria_multiline@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_multiline: *mut nsAtom; + #[link_name = "?aria_multiselectable@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_multiselectable: *mut nsAtom; + #[link_name = "?aria_owns@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_owns: *mut nsAtom; + #[link_name = "?aria_posinset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_posinset: *mut nsAtom; + #[link_name = "?aria_pressed@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_pressed: *mut nsAtom; + #[link_name = "?aria_readonly@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_readonly: *mut nsAtom; + #[link_name = "?aria_relevant@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_relevant: *mut nsAtom; + #[link_name = "?aria_required@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_required: *mut nsAtom; + #[link_name = "?aria_selected@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_selected: *mut nsAtom; + #[link_name = "?aria_setsize@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_setsize: *mut nsAtom; + #[link_name = "?aria_sort@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_sort: *mut nsAtom; + #[link_name = "?aria_valuemax@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_valuemax: *mut nsAtom; + #[link_name = "?aria_valuemin@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_valuemin: *mut nsAtom; + #[link_name = "?aria_valuenow@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_valuenow: *mut nsAtom; + #[link_name = "?arrow@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_arrow: *mut nsAtom; + #[link_name = "?article@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_article: *mut nsAtom; + #[link_name = "?as@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_as: *mut nsAtom; + #[link_name = "?ascending@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ascending: *mut nsAtom; + #[link_name = "?aside@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aside: *mut nsAtom; + #[link_name = "?aspectRatio@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aspectRatio: *mut nsAtom; + #[link_name = "?assign@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_assign: *mut nsAtom; + #[link_name = "?async@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_async: *mut nsAtom; + #[link_name = "?attribute@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_attribute: *mut nsAtom; + #[link_name = "?attributes@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_attributes: *mut nsAtom; + #[link_name = "?attributeSet@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_attributeSet: *mut nsAtom; + #[link_name = "?aural@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aural: *mut nsAtom; + #[link_name = "?_auto@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__auto: *mut nsAtom; + #[link_name = "?autocheck@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_autocheck: *mut nsAtom; + #[link_name = "?autocomplete@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_autocomplete: *mut nsAtom; + #[link_name = "?autofocus@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_autofocus: *mut nsAtom; + #[link_name = "?autoplay@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_autoplay: *mut nsAtom; + #[link_name = "?autorepeatbutton@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_autorepeatbutton: *mut nsAtom; + #[link_name = "?axis@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_axis: *mut nsAtom; + #[link_name = "?b@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_b: *mut nsAtom; + #[link_name = "?background@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_background: *mut nsAtom; + #[link_name = "?base@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_base: *mut nsAtom; + #[link_name = "?basefont@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_basefont: *mut nsAtom; + #[link_name = "?baseline@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_baseline: *mut nsAtom; + #[link_name = "?bdi@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_bdi: *mut nsAtom; + #[link_name = "?bdo@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_bdo: *mut nsAtom; + #[link_name = "?before@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_before: *mut nsAtom; + #[link_name = "?before_end@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_before_end: *mut nsAtom; + #[link_name = "?before_start@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_before_start: *mut nsAtom; + #[link_name = "?below@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_below: *mut nsAtom; + #[link_name = "?bgcolor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_bgcolor: *mut nsAtom; + #[link_name = "?bgsound@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_bgsound: *mut nsAtom; + #[link_name = "?big@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_big: *mut nsAtom; + #[link_name = "?binding@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_binding: *mut nsAtom; + #[link_name = "?bindings@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_bindings: *mut nsAtom; + #[link_name = "?bindToUntrustedContent@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_bindToUntrustedContent: *mut nsAtom; + #[link_name = "?blankrow@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_blankrow: *mut nsAtom; + #[link_name = "?block@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_block: *mut nsAtom; + #[link_name = "?blockquote@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_blockquote: *mut nsAtom; + #[link_name = "?blur@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_blur: *mut nsAtom; + #[link_name = "?body@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_body: *mut nsAtom; + #[link_name = "?boolean@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_boolean: *mut nsAtom; + #[link_name = "?border@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_border: *mut nsAtom; + #[link_name = "?bordercolor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_bordercolor: *mut nsAtom; + #[link_name = "?both@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_both: *mut nsAtom; + #[link_name = "?bottom@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_bottom: *mut nsAtom; + #[link_name = "?bottomend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_bottomend: *mut nsAtom; + #[link_name = "?bottomstart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_bottomstart: *mut nsAtom; + #[link_name = "?bottomleft@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_bottomleft: *mut nsAtom; + #[link_name = "?bottommargin@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_bottommargin: *mut nsAtom; + #[link_name = "?bottompadding@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_bottompadding: *mut nsAtom; + #[link_name = "?bottomright@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_bottomright: *mut nsAtom; + #[link_name = "?box@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_box: *mut nsAtom; + #[link_name = "?br@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_br: *mut nsAtom; + #[link_name = "?braille@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_braille: *mut nsAtom; + #[link_name = "?broadcast@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_broadcast: *mut nsAtom; + #[link_name = "?broadcaster@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_broadcaster: *mut nsAtom; + #[link_name = "?broadcasterset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_broadcasterset: *mut nsAtom; + #[link_name = "?browser@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_browser: *mut nsAtom; + #[link_name = "?mozbrowser@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozbrowser: *mut nsAtom; + #[link_name = "?bulletinboard@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_bulletinboard: *mut nsAtom; + #[link_name = "?button@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_button: *mut nsAtom; + #[link_name = "?brighttitlebarforeground@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_brighttitlebarforeground: *mut nsAtom; + #[link_name = "?callTemplate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_callTemplate: *mut nsAtom; + #[link_name = "?cancel@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cancel: *mut nsAtom; + #[link_name = "?canvas@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_canvas: *mut nsAtom; + #[link_name = "?caption@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_caption: *mut nsAtom; + #[link_name = "?capture@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_capture: *mut nsAtom; + #[link_name = "?caseOrder@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_caseOrder: *mut nsAtom; + #[link_name = "?cdataSectionElements@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cdataSectionElements: *mut nsAtom; + #[link_name = "?ceiling@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ceiling: *mut nsAtom; + #[link_name = "?cell@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cell: *mut nsAtom; + #[link_name = "?cellpadding@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cellpadding: *mut nsAtom; + #[link_name = "?cellspacing@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cellspacing: *mut nsAtom; + #[link_name = "?center@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_center: *mut nsAtom; + #[link_name = "?ch@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ch: *mut nsAtom; + #[link_name = "?change@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_change: *mut nsAtom; + #[link_name = "?_char@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__char: *mut nsAtom; + #[link_name = "?characterData@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_characterData: *mut nsAtom; + #[link_name = "?charcode@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_charcode: *mut nsAtom; + #[link_name = "?charoff@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_charoff: *mut nsAtom; + #[link_name = "?charset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_charset: *mut nsAtom; + #[link_name = "?checkbox@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_checkbox: *mut nsAtom; + #[link_name = "?checked@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_checked: *mut nsAtom; + #[link_name = "?child@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_child: *mut nsAtom; + #[link_name = "?children@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_children: *mut nsAtom; + #[link_name = "?childList@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_childList: *mut nsAtom; + #[link_name = "?choose@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_choose: *mut nsAtom; + #[link_name = "?chromemargin@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_chromemargin: *mut nsAtom; + #[link_name = "?chromeOnlyContent@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_chromeOnlyContent: *mut nsAtom; + #[link_name = "?exposeToUntrustedContent@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_exposeToUntrustedContent: *mut nsAtom; + #[link_name = "?circ@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_circ: *mut nsAtom; + #[link_name = "?circle@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_circle: *mut nsAtom; + #[link_name = "?cite@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cite: *mut nsAtom; + #[link_name = "?cjkDecimal@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cjkDecimal: *mut nsAtom; + #[link_name = "?_class@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__class: *mut nsAtom; + #[link_name = "?classid@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_classid: *mut nsAtom; + #[link_name = "?clear@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_clear: *mut nsAtom; + #[link_name = "?click@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_click: *mut nsAtom; + #[link_name = "?clickcount@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_clickcount: *mut nsAtom; + #[link_name = "?clickthrough@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_clickthrough: *mut nsAtom; + #[link_name = "?movetoclick@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_movetoclick: *mut nsAtom; + #[link_name = "?clip@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_clip: *mut nsAtom; + #[link_name = "?close@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_close: *mut nsAtom; + #[link_name = "?closed@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_closed: *mut nsAtom; + #[link_name = "?closemenu@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_closemenu: *mut nsAtom; + #[link_name = "?coalesceduplicatearcs@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_coalesceduplicatearcs: *mut nsAtom; + #[link_name = "?code@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_code: *mut nsAtom; + #[link_name = "?codebase@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_codebase: *mut nsAtom; + #[link_name = "?codetype@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_codetype: *mut nsAtom; + #[link_name = "?col@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_col: *mut nsAtom; + #[link_name = "?colgroup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_colgroup: *mut nsAtom; + #[link_name = "?collapse@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_collapse: *mut nsAtom; + #[link_name = "?collapsed@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_collapsed: *mut nsAtom; + #[link_name = "?color@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_color: *mut nsAtom; + #[link_name = "?colorIndex@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_colorIndex: *mut nsAtom; + #[link_name = "?cols@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cols: *mut nsAtom; + #[link_name = "?colspan@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_colspan: *mut nsAtom; + #[link_name = "?column@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_column: *mut nsAtom; + #[link_name = "?columns@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_columns: *mut nsAtom; + #[link_name = "?combobox@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_combobox: *mut nsAtom; + #[link_name = "?command@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_command: *mut nsAtom; + #[link_name = "?commands@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_commands: *mut nsAtom; + #[link_name = "?commandset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_commandset: *mut nsAtom; + #[link_name = "?commandupdate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_commandupdate: *mut nsAtom; + #[link_name = "?commandupdater@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_commandupdater: *mut nsAtom; + #[link_name = "?comment@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_comment: *mut nsAtom; + #[link_name = "?compact@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_compact: *mut nsAtom; + #[link_name = "?concat@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_concat: *mut nsAtom; + #[link_name = "?conditions@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_conditions: *mut nsAtom; + #[link_name = "?constructor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_constructor: *mut nsAtom; + #[link_name = "?consumeoutsideclicks@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_consumeoutsideclicks: *mut nsAtom; + #[link_name = "?container@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_container: *mut nsAtom; + #[link_name = "?containment@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_containment: *mut nsAtom; + #[link_name = "?contains@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_contains: *mut nsAtom; + #[link_name = "?content@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_content: *mut nsAtom; + #[link_name = "?contenteditable@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_contenteditable: *mut nsAtom; + #[link_name = "?headerContentDisposition@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_headerContentDisposition: *mut nsAtom; + #[link_name = "?headerContentLanguage@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_headerContentLanguage: *mut nsAtom; + #[link_name = "?contentLocation@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_contentLocation: *mut nsAtom; + #[link_name = "?headerContentScriptType@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_headerContentScriptType: *mut nsAtom; + #[link_name = "?headerContentStyleType@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_headerContentStyleType: *mut nsAtom; + #[link_name = "?headerContentType@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_headerContentType: *mut nsAtom; + #[link_name = "?consumeanchor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_consumeanchor: *mut nsAtom; + #[link_name = "?context@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_context: *mut nsAtom; + #[link_name = "?contextmenu@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_contextmenu: *mut nsAtom; + #[link_name = "?control@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_control: *mut nsAtom; + #[link_name = "?controls@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_controls: *mut nsAtom; + #[link_name = "?coords@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_coords: *mut nsAtom; + #[link_name = "?copy@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_copy: *mut nsAtom; + #[link_name = "?copyOf@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_copyOf: *mut nsAtom; + #[link_name = "?count@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_count: *mut nsAtom; + #[link_name = "?crop@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_crop: *mut nsAtom; + #[link_name = "?crossorigin@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_crossorigin: *mut nsAtom; + #[link_name = "?curpos@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_curpos: *mut nsAtom; + #[link_name = "?current@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_current: *mut nsAtom; + #[link_name = "?cutoutregion@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cutoutregion: *mut nsAtom; + #[link_name = "?cycler@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cycler: *mut nsAtom; + #[link_name = "?data@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_data: *mut nsAtom; + #[link_name = "?datalist@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_datalist: *mut nsAtom; + #[link_name = "?dataType@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dataType: *mut nsAtom; + #[link_name = "?dateTime@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dateTime: *mut nsAtom; + #[link_name = "?datasources@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_datasources: *mut nsAtom; + #[link_name = "?datetime@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_datetime: *mut nsAtom; + #[link_name = "?datetimebox@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_datetimebox: *mut nsAtom; + #[link_name = "?dblclick@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dblclick: *mut nsAtom; + #[link_name = "?dd@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dd: *mut nsAtom; + #[link_name = "?debug@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_debug: *mut nsAtom; + #[link_name = "?decimal@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_decimal: *mut nsAtom; + #[link_name = "?decimalFormat@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_decimalFormat: *mut nsAtom; + #[link_name = "?decimalSeparator@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_decimalSeparator: *mut nsAtom; + #[link_name = "?deck@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_deck: *mut nsAtom; + #[link_name = "?declare@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_declare: *mut nsAtom; + #[link_name = "?decoderDoctor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_decoderDoctor: *mut nsAtom; + #[link_name = "?decrement@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_decrement: *mut nsAtom; + #[link_name = "?_default@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__default: *mut nsAtom; + #[link_name = "?headerDefaultStyle@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_headerDefaultStyle: *mut nsAtom; + #[link_name = "?defaultAction@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_defaultAction: *mut nsAtom; + #[link_name = "?defaultchecked@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_defaultchecked: *mut nsAtom; + #[link_name = "?defaultLabel@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_defaultLabel: *mut nsAtom; + #[link_name = "?defaultselected@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_defaultselected: *mut nsAtom; + #[link_name = "?defaultvalue@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_defaultvalue: *mut nsAtom; + #[link_name = "?defaultplaybackrate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_defaultplaybackrate: *mut nsAtom; + #[link_name = "?defer@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_defer: *mut nsAtom; + #[link_name = "?del@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_del: *mut nsAtom; + #[link_name = "?descendant@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_descendant: *mut nsAtom; + #[link_name = "?descendantOrSelf@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_descendantOrSelf: *mut nsAtom; + #[link_name = "?descending@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_descending: *mut nsAtom; + #[link_name = "?description@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_description: *mut nsAtom; + #[link_name = "?destructor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_destructor: *mut nsAtom; + #[link_name = "?details@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_details: *mut nsAtom; + #[link_name = "?deviceAspectRatio@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_deviceAspectRatio: *mut nsAtom; + #[link_name = "?deviceHeight@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_deviceHeight: *mut nsAtom; + #[link_name = "?devicePixelRatio@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_devicePixelRatio: *mut nsAtom; + #[link_name = "?deviceWidth@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_deviceWidth: *mut nsAtom; + #[link_name = "?dfn@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dfn: *mut nsAtom; + #[link_name = "?dialog@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dialog: *mut nsAtom; + #[link_name = "?difference@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_difference: *mut nsAtom; + #[link_name = "?digit@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_digit: *mut nsAtom; + #[link_name = "?dir@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dir: *mut nsAtom; + #[link_name = "?dirAutoSetBy@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dirAutoSetBy: *mut nsAtom; + #[link_name = "?directionality@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_directionality: *mut nsAtom; + #[link_name = "?directory@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_directory: *mut nsAtom; + #[link_name = "?disableOutputEscaping@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_disableOutputEscaping: *mut nsAtom; + #[link_name = "?disabled@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_disabled: *mut nsAtom; + #[link_name = "?disableglobalhistory@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_disableglobalhistory: *mut nsAtom; + #[link_name = "?disablehistory@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_disablehistory: *mut nsAtom; + #[link_name = "?disablefullscreen@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_disablefullscreen: *mut nsAtom; + #[link_name = "?disclosure_closed@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_disclosure_closed: *mut nsAtom; + #[link_name = "?disclosure_open@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_disclosure_open: *mut nsAtom; + #[link_name = "?display@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_display: *mut nsAtom; + #[link_name = "?displayMode@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_displayMode: *mut nsAtom; + #[link_name = "?distinct@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_distinct: *mut nsAtom; + #[link_name = "?div@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_div: *mut nsAtom; + #[link_name = "?dl@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dl: *mut nsAtom; + #[link_name = "?docAbstract@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docAbstract: *mut nsAtom; + #[link_name = "?docAcknowledgments@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docAcknowledgments: *mut nsAtom; + #[link_name = "?docAfterword@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docAfterword: *mut nsAtom; + #[link_name = "?docAppendix@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docAppendix: *mut nsAtom; + #[link_name = "?docBacklink@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docBacklink: *mut nsAtom; + #[link_name = "?docBiblioentry@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docBiblioentry: *mut nsAtom; + #[link_name = "?docBibliography@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docBibliography: *mut nsAtom; + #[link_name = "?docBiblioref@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docBiblioref: *mut nsAtom; + #[link_name = "?docChapter@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docChapter: *mut nsAtom; + #[link_name = "?docColophon@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docColophon: *mut nsAtom; + #[link_name = "?docConclusion@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docConclusion: *mut nsAtom; + #[link_name = "?docCover@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docCover: *mut nsAtom; + #[link_name = "?docCredit@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docCredit: *mut nsAtom; + #[link_name = "?docCredits@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docCredits: *mut nsAtom; + #[link_name = "?docDedication@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docDedication: *mut nsAtom; + #[link_name = "?docEndnote@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docEndnote: *mut nsAtom; + #[link_name = "?docEndnotes@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docEndnotes: *mut nsAtom; + #[link_name = "?docEpigraph@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docEpigraph: *mut nsAtom; + #[link_name = "?docEpilogue@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docEpilogue: *mut nsAtom; + #[link_name = "?docErrata@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docErrata: *mut nsAtom; + #[link_name = "?docExample@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docExample: *mut nsAtom; + #[link_name = "?docFootnote@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docFootnote: *mut nsAtom; + #[link_name = "?docForeword@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docForeword: *mut nsAtom; + #[link_name = "?docGlossary@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docGlossary: *mut nsAtom; + #[link_name = "?docGlossref@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docGlossref: *mut nsAtom; + #[link_name = "?docIndex@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docIndex: *mut nsAtom; + #[link_name = "?docIntroduction@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docIntroduction: *mut nsAtom; + #[link_name = "?docNoteref@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docNoteref: *mut nsAtom; + #[link_name = "?docNotice@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docNotice: *mut nsAtom; + #[link_name = "?docPagebreak@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docPagebreak: *mut nsAtom; + #[link_name = "?docPagelist@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docPagelist: *mut nsAtom; + #[link_name = "?docPart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docPart: *mut nsAtom; + #[link_name = "?docPreface@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docPreface: *mut nsAtom; + #[link_name = "?docPrologue@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docPrologue: *mut nsAtom; + #[link_name = "?docPullquote@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docPullquote: *mut nsAtom; + #[link_name = "?docQna@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docQna: *mut nsAtom; + #[link_name = "?docSubtitle@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docSubtitle: *mut nsAtom; + #[link_name = "?docTip@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docTip: *mut nsAtom; + #[link_name = "?docToc@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_docToc: *mut nsAtom; + #[link_name = "?doctypePublic@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_doctypePublic: *mut nsAtom; + #[link_name = "?doctypeSystem@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_doctypeSystem: *mut nsAtom; + #[link_name = "?document@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_document: *mut nsAtom; + #[link_name = "?download@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_download: *mut nsAtom; + #[link_name = "?DOMAttrModified@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_DOMAttrModified: *mut nsAtom; + #[link_name = "?DOMCharacterDataModified@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_DOMCharacterDataModified: *mut nsAtom; + #[link_name = "?DOMNodeInserted@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_DOMNodeInserted: *mut nsAtom; + #[link_name = "?DOMNodeInsertedIntoDocument@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_DOMNodeInsertedIntoDocument: *mut nsAtom; + #[link_name = "?DOMNodeRemoved@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_DOMNodeRemoved: *mut nsAtom; + #[link_name = "?DOMNodeRemovedFromDocument@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_DOMNodeRemovedFromDocument: *mut nsAtom; + #[link_name = "?DOMSubtreeModified@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_DOMSubtreeModified: *mut nsAtom; + #[link_name = "?double_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_double_: *mut nsAtom; + #[link_name = "?drag@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_drag: *mut nsAtom; + #[link_name = "?dragend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dragend: *mut nsAtom; + #[link_name = "?dragenter@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dragenter: *mut nsAtom; + #[link_name = "?dragevent@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dragevent: *mut nsAtom; + #[link_name = "?dragexit@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dragexit: *mut nsAtom; + #[link_name = "?draggable@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_draggable: *mut nsAtom; + #[link_name = "?dragging@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dragging: *mut nsAtom; + #[link_name = "?dragleave@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dragleave: *mut nsAtom; + #[link_name = "?dragover@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dragover: *mut nsAtom; + #[link_name = "?dragSession@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dragSession: *mut nsAtom; + #[link_name = "?dragstart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dragstart: *mut nsAtom; + #[link_name = "?drawintitlebar@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_drawintitlebar: *mut nsAtom; + #[link_name = "?drawtitle@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_drawtitle: *mut nsAtom; + #[link_name = "?drop@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_drop: *mut nsAtom; + #[link_name = "?dropAfter@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dropAfter: *mut nsAtom; + #[link_name = "?dropBefore@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dropBefore: *mut nsAtom; + #[link_name = "?dropOn@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dropOn: *mut nsAtom; + #[link_name = "?dropMarker@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dropMarker: *mut nsAtom; + #[link_name = "?dt@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dt: *mut nsAtom; + #[link_name = "?editable@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_editable: *mut nsAtom; + #[link_name = "?editing@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_editing: *mut nsAtom; + #[link_name = "?editor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_editor: *mut nsAtom; + #[link_name = "?editorDisplayList@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_editorDisplayList: *mut nsAtom; + #[link_name = "?element@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_element: *mut nsAtom; + #[link_name = "?elementAvailable@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_elementAvailable: *mut nsAtom; + #[link_name = "?elements@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_elements: *mut nsAtom; + #[link_name = "?em@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_em: *mut nsAtom; + #[link_name = "?embed@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_embed: *mut nsAtom; + #[link_name = "?embossed@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_embossed: *mut nsAtom; + #[link_name = "?empty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_empty: *mut nsAtom; + #[link_name = "?encoding@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_encoding: *mut nsAtom; + #[link_name = "?enctype@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_enctype: *mut nsAtom; + #[link_name = "?end@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_end: *mut nsAtom; + #[link_name = "?endEvent@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_endEvent: *mut nsAtom; + #[link_name = "?end_after@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_end_after: *mut nsAtom; + #[link_name = "?end_before@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_end_before: *mut nsAtom; + #[link_name = "?equalsize@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_equalsize: *mut nsAtom; + #[link_name = "?error@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_error: *mut nsAtom; + #[link_name = "?ethiopic_numeric@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ethiopic_numeric: *mut nsAtom; + #[link_name = "?even@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_even: *mut nsAtom; + #[link_name = "?event@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_event: *mut nsAtom; + #[link_name = "?events@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_events: *mut nsAtom; + #[link_name = "?excludeResultPrefixes@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_excludeResultPrefixes: *mut nsAtom; + #[link_name = "?excludes@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_excludes: *mut nsAtom; + #[link_name = "?expr@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_expr: *mut nsAtom; + #[link_name = "?extends@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_extends: *mut nsAtom; + #[link_name = "?extensionElementPrefixes@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_extensionElementPrefixes: *mut nsAtom; + #[link_name = "?face@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_face: *mut nsAtom; + #[link_name = "?fallback@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fallback: *mut nsAtom; + #[link_name = "?_false@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__false: *mut nsAtom; + #[link_name = "?farthest@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_farthest: *mut nsAtom; + #[link_name = "?field@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_field: *mut nsAtom; + #[link_name = "?fieldset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fieldset: *mut nsAtom; + #[link_name = "?file@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_file: *mut nsAtom; + #[link_name = "?figcaption@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_figcaption: *mut nsAtom; + #[link_name = "?figure@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_figure: *mut nsAtom; + #[link_name = "?fixed@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fixed: *mut nsAtom; + #[link_name = "?flags@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_flags: *mut nsAtom; + #[link_name = "?flex@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_flex: *mut nsAtom; + #[link_name = "?flexgroup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_flexgroup: *mut nsAtom; + #[link_name = "?flip@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_flip: *mut nsAtom; + #[link_name = "?floating@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_floating: *mut nsAtom; + #[link_name = "?floor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_floor: *mut nsAtom; + #[link_name = "?flowlength@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_flowlength: *mut nsAtom; + #[link_name = "?focus@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_focus: *mut nsAtom; + #[link_name = "?focused@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_focused: *mut nsAtom; + #[link_name = "?followanchor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_followanchor: *mut nsAtom; + #[link_name = "?following@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_following: *mut nsAtom; + #[link_name = "?followingSibling@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_followingSibling: *mut nsAtom; + #[link_name = "?font@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_font: *mut nsAtom; + #[link_name = "?fontWeight@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fontWeight: *mut nsAtom; + #[link_name = "?fontpicker@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fontpicker: *mut nsAtom; + #[link_name = "?footer@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_footer: *mut nsAtom; + #[link_name = "?_for@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__for: *mut nsAtom; + #[link_name = "?forEach@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_forEach: *mut nsAtom; + #[link_name = "?forceOwnRefreshDriver@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_forceOwnRefreshDriver: *mut nsAtom; + #[link_name = "?form@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_form: *mut nsAtom; + #[link_name = "?formaction@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_formaction: *mut nsAtom; + #[link_name = "?format@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_format: *mut nsAtom; + #[link_name = "?formatNumber@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_formatNumber: *mut nsAtom; + #[link_name = "?formenctype@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_formenctype: *mut nsAtom; + #[link_name = "?formmethod@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_formmethod: *mut nsAtom; + #[link_name = "?formnovalidate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_formnovalidate: *mut nsAtom; + #[link_name = "?formtarget@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_formtarget: *mut nsAtom; + #[link_name = "?frame@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_frame: *mut nsAtom; + #[link_name = "?frameborder@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_frameborder: *mut nsAtom; + #[link_name = "?frameset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_frameset: *mut nsAtom; + #[link_name = "?from@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_from: *mut nsAtom; + #[link_name = "?fullscreenchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fullscreenchange: *mut nsAtom; + #[link_name = "?fullscreenerror@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fullscreenerror: *mut nsAtom; + #[link_name = "?functionAvailable@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_functionAvailable: *mut nsAtom; + #[link_name = "?freshProcess@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_freshProcess: *mut nsAtom; + #[link_name = "?generateId@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_generateId: *mut nsAtom; + #[link_name = "?getter@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_getter: *mut nsAtom; + #[link_name = "?glyphchar@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_glyphchar: *mut nsAtom; + #[link_name = "?glyphid@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_glyphid: *mut nsAtom; + #[link_name = "?grid@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_grid: *mut nsAtom; + #[link_name = "?grippy@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_grippy: *mut nsAtom; + #[link_name = "?group@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_group: *mut nsAtom; + #[link_name = "?groupingSeparator@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_groupingSeparator: *mut nsAtom; + #[link_name = "?groupingSize@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_groupingSize: *mut nsAtom; + #[link_name = "?grow@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_grow: *mut nsAtom; + #[link_name = "?gutter@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_gutter: *mut nsAtom; + #[link_name = "?h1@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_h1: *mut nsAtom; + #[link_name = "?h2@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_h2: *mut nsAtom; + #[link_name = "?h3@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_h3: *mut nsAtom; + #[link_name = "?h4@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_h4: *mut nsAtom; + #[link_name = "?h5@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_h5: *mut nsAtom; + #[link_name = "?h6@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_h6: *mut nsAtom; + #[link_name = "?handheld@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_handheld: *mut nsAtom; + #[link_name = "?handheldFriendly@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_handheldFriendly: *mut nsAtom; + #[link_name = "?handler@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_handler: *mut nsAtom; + #[link_name = "?handlers@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_handlers: *mut nsAtom; + #[link_name = "?HARD@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_HARD: *mut nsAtom; + #[link_name = "?haspopup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_haspopup: *mut nsAtom; + #[link_name = "?hasSameNode@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_hasSameNode: *mut nsAtom; + #[link_name = "?hbox@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_hbox: *mut nsAtom; + #[link_name = "?head@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_head: *mut nsAtom; + #[link_name = "?header@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_header: *mut nsAtom; + #[link_name = "?headers@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_headers: *mut nsAtom; + #[link_name = "?hebrew@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_hebrew: *mut nsAtom; + #[link_name = "?height@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_height: *mut nsAtom; + #[link_name = "?hgroup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_hgroup: *mut nsAtom; + #[link_name = "?hidden@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_hidden: *mut nsAtom; + #[link_name = "?hidechrome@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_hidechrome: *mut nsAtom; + #[link_name = "?hidecolumnpicker@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_hidecolumnpicker: *mut nsAtom; + #[link_name = "?high@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_high: *mut nsAtom; + #[link_name = "?highest@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_highest: *mut nsAtom; + #[link_name = "?horizontal@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_horizontal: *mut nsAtom; + #[link_name = "?hover@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_hover: *mut nsAtom; + #[link_name = "?hr@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_hr: *mut nsAtom; + #[link_name = "?href@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_href: *mut nsAtom; + #[link_name = "?hreflang@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_hreflang: *mut nsAtom; + #[link_name = "?hspace@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_hspace: *mut nsAtom; + #[link_name = "?html@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_html: *mut nsAtom; + #[link_name = "?httpEquiv@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_httpEquiv: *mut nsAtom; + #[link_name = "?i@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_i: *mut nsAtom; + #[link_name = "?icon@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_icon: *mut nsAtom; + #[link_name = "?id@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_id: *mut nsAtom; + #[link_name = "?_if@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__if: *mut nsAtom; + #[link_name = "?iframe@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_iframe: *mut nsAtom; + #[link_name = "?ignorecase@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ignorecase: *mut nsAtom; + #[link_name = "?ignorekeys@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ignorekeys: *mut nsAtom; + #[link_name = "?ignoreuserfocus@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ignoreuserfocus: *mut nsAtom; + #[link_name = "?ilayer@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ilayer: *mut nsAtom; + #[link_name = "?image@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_image: *mut nsAtom; + #[link_name = "?imageClickedPoint@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_imageClickedPoint: *mut nsAtom; + #[link_name = "?img@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_img: *mut nsAtom; + #[link_name = "?implementation@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_implementation: *mut nsAtom; + #[link_name = "?implements@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_implements: *mut nsAtom; + #[link_name = "?import@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_import: *mut nsAtom; + #[link_name = "?inactivetitlebarcolor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_inactivetitlebarcolor: *mut nsAtom; + #[link_name = "?include@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_include: *mut nsAtom; + #[link_name = "?includes@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_includes: *mut nsAtom; + #[link_name = "?increment@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_increment: *mut nsAtom; + #[link_name = "?indent@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_indent: *mut nsAtom; + #[link_name = "?indeterminate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_indeterminate: *mut nsAtom; + #[link_name = "?index@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_index: *mut nsAtom; + #[link_name = "?infer@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_infer: *mut nsAtom; + #[link_name = "?infinity@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_infinity: *mut nsAtom; + #[link_name = "?inherit@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_inherit: *mut nsAtom; + #[link_name = "?inherits@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_inherits: *mut nsAtom; + #[link_name = "?inheritstyle@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_inheritstyle: *mut nsAtom; + #[link_name = "?initial_scale@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_initial_scale: *mut nsAtom; + #[link_name = "?input@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_input: *mut nsAtom; + #[link_name = "?inputmode@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_inputmode: *mut nsAtom; + #[link_name = "?ins@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ins: *mut nsAtom; + #[link_name = "?insertafter@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_insertafter: *mut nsAtom; + #[link_name = "?insertbefore@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_insertbefore: *mut nsAtom; + #[link_name = "?install@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_install: *mut nsAtom; + #[link_name = "?instanceOf@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_instanceOf: *mut nsAtom; + #[link_name = "?int32@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_int32: *mut nsAtom; + #[link_name = "?int64@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_int64: *mut nsAtom; + #[link_name = "?integer@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_integer: *mut nsAtom; + #[link_name = "?integrity@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_integrity: *mut nsAtom; + #[link_name = "?intersection@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_intersection: *mut nsAtom; + #[link_name = "?is@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_is: *mut nsAtom; + #[link_name = "?iscontainer@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_iscontainer: *mut nsAtom; + #[link_name = "?isempty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_isempty: *mut nsAtom; + #[link_name = "?ismap@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ismap: *mut nsAtom; + #[link_name = "?itemid@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_itemid: *mut nsAtom; + #[link_name = "?itemprop@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_itemprop: *mut nsAtom; + #[link_name = "?itemref@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_itemref: *mut nsAtom; + #[link_name = "?itemscope@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_itemscope: *mut nsAtom; + #[link_name = "?itemtype@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_itemtype: *mut nsAtom; + #[link_name = "?japanese_formal@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_japanese_formal: *mut nsAtom; + #[link_name = "?japanese_informal@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_japanese_informal: *mut nsAtom; + #[link_name = "?kbd@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_kbd: *mut nsAtom; + #[link_name = "?keepcurrentinview@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_keepcurrentinview: *mut nsAtom; + #[link_name = "?keepobjectsalive@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_keepobjectsalive: *mut nsAtom; + #[link_name = "?key@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_key: *mut nsAtom; + #[link_name = "?keycode@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_keycode: *mut nsAtom; + #[link_name = "?keystatuseschange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_keystatuseschange: *mut nsAtom; + #[link_name = "?keydown@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_keydown: *mut nsAtom; + #[link_name = "?keygen@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_keygen: *mut nsAtom; + #[link_name = "?keypress@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_keypress: *mut nsAtom; + #[link_name = "?keyset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_keyset: *mut nsAtom; + #[link_name = "?keysystem@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_keysystem: *mut nsAtom; + #[link_name = "?keytext@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_keytext: *mut nsAtom; + #[link_name = "?keyup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_keyup: *mut nsAtom; + #[link_name = "?kind@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_kind: *mut nsAtom; + #[link_name = "?korean_hangul_formal@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_korean_hangul_formal: *mut nsAtom; + #[link_name = "?korean_hanja_formal@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_korean_hanja_formal: *mut nsAtom; + #[link_name = "?korean_hanja_informal@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_korean_hanja_informal: *mut nsAtom; + #[link_name = "?label@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_label: *mut nsAtom; + #[link_name = "?labels@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_labels: *mut nsAtom; + #[link_name = "?lang@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lang: *mut nsAtom; + #[link_name = "?language@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_language: *mut nsAtom; + #[link_name = "?last@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_last: *mut nsAtom; + #[link_name = "?layer@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_layer: *mut nsAtom; + #[link_name = "?LayerActivity@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_LayerActivity: *mut nsAtom; + #[link_name = "?layout@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_layout: *mut nsAtom; + #[link_name = "?leading@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_leading: *mut nsAtom; + #[link_name = "?leaf@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_leaf: *mut nsAtom; + #[link_name = "?left@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_left: *mut nsAtom; + #[link_name = "?leftmargin@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_leftmargin: *mut nsAtom; + #[link_name = "?leftpadding@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_leftpadding: *mut nsAtom; + #[link_name = "?legend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_legend: *mut nsAtom; + #[link_name = "?length@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_length: *mut nsAtom; + #[link_name = "?letterValue@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_letterValue: *mut nsAtom; + #[link_name = "?level@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_level: *mut nsAtom; + #[link_name = "?li@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_li: *mut nsAtom; + #[link_name = "?line@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_line: *mut nsAtom; + #[link_name = "?link@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_link: *mut nsAtom; + #[link_name = "?list@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_list: *mut nsAtom; + #[link_name = "?listbox@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_listbox: *mut nsAtom; + #[link_name = "?listboxbody@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_listboxbody: *mut nsAtom; + #[link_name = "?listcell@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_listcell: *mut nsAtom; + #[link_name = "?listcol@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_listcol: *mut nsAtom; + #[link_name = "?listcols@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_listcols: *mut nsAtom; + #[link_name = "?listener@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_listener: *mut nsAtom; + #[link_name = "?listhead@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_listhead: *mut nsAtom; + #[link_name = "?listheader@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_listheader: *mut nsAtom; + #[link_name = "?listing@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_listing: *mut nsAtom; + #[link_name = "?listitem@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_listitem: *mut nsAtom; + #[link_name = "?listrows@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_listrows: *mut nsAtom; + #[link_name = "?load@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_load: *mut nsAtom; + #[link_name = "?loadingprincipal@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_loadingprincipal: *mut nsAtom; + #[link_name = "?localedir@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_localedir: *mut nsAtom; + #[link_name = "?localName@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_localName: *mut nsAtom; + #[link_name = "?longdesc@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_longdesc: *mut nsAtom; + #[link_name = "?loop@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_loop: *mut nsAtom; + #[link_name = "?low@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_low: *mut nsAtom; + #[link_name = "?lowerAlpha@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lowerAlpha: *mut nsAtom; + #[link_name = "?lowerFirst@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lowerFirst: *mut nsAtom; + #[link_name = "?lowerRoman@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lowerRoman: *mut nsAtom; + #[link_name = "?lowest@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lowest: *mut nsAtom; + #[link_name = "?lowsrc@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lowsrc: *mut nsAtom; + #[link_name = "?ltr@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ltr: *mut nsAtom; + #[link_name = "?lwtheme@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lwtheme: *mut nsAtom; + #[link_name = "?lwthemetextcolor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lwthemetextcolor: *mut nsAtom; + #[link_name = "?main@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_main: *mut nsAtom; + #[link_name = "?map@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_map: *mut nsAtom; + #[link_name = "?manifest@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_manifest: *mut nsAtom; + #[link_name = "?marginBottom@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_marginBottom: *mut nsAtom; + #[link_name = "?marginLeft@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_marginLeft: *mut nsAtom; + #[link_name = "?marginRight@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_marginRight: *mut nsAtom; + #[link_name = "?marginTop@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_marginTop: *mut nsAtom; + #[link_name = "?marginheight@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_marginheight: *mut nsAtom; + #[link_name = "?marginwidth@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_marginwidth: *mut nsAtom; + #[link_name = "?mark@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mark: *mut nsAtom; + #[link_name = "?marquee@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_marquee: *mut nsAtom; + #[link_name = "?match@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_match: *mut nsAtom; + #[link_name = "?max@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_max: *mut nsAtom; + #[link_name = "?maxheight@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_maxheight: *mut nsAtom; + #[link_name = "?maximum_scale@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_maximum_scale: *mut nsAtom; + #[link_name = "?maxlength@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_maxlength: *mut nsAtom; + #[link_name = "?maxpos@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_maxpos: *mut nsAtom; + #[link_name = "?maxwidth@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_maxwidth: *mut nsAtom; + #[link_name = "?mayscript@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mayscript: *mut nsAtom; + #[link_name = "?media@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_media: *mut nsAtom; + #[link_name = "?mediaType@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mediaType: *mut nsAtom; + #[link_name = "?member@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_member: *mut nsAtom; + #[link_name = "?menu@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_menu: *mut nsAtom; + #[link_name = "?menubar@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_menubar: *mut nsAtom; + #[link_name = "?menubutton@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_menubutton: *mut nsAtom; + #[link_name = "?menuButton@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_menuButton: *mut nsAtom; + #[link_name = "?menugroup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_menugroup: *mut nsAtom; + #[link_name = "?menuitem@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_menuitem: *mut nsAtom; + #[link_name = "?menulist@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_menulist: *mut nsAtom; + #[link_name = "?menupopup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_menupopup: *mut nsAtom; + #[link_name = "?menuseparator@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_menuseparator: *mut nsAtom; + #[link_name = "?message@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_message: *mut nsAtom; + #[link_name = "?meta@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_meta: *mut nsAtom; + #[link_name = "?referrer@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_referrer: *mut nsAtom; + #[link_name = "?referrerpolicy@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_referrerpolicy: *mut nsAtom; + #[link_name = "?headerReferrerPolicy@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_headerReferrerPolicy: *mut nsAtom; + #[link_name = "?meter@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_meter: *mut nsAtom; + #[link_name = "?method@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_method: *mut nsAtom; + #[link_name = "?middle@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_middle: *mut nsAtom; + #[link_name = "?min@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_min: *mut nsAtom; + #[link_name = "?minheight@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_minheight: *mut nsAtom; + #[link_name = "?minimum_scale@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_minimum_scale: *mut nsAtom; + #[link_name = "?minlength@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_minlength: *mut nsAtom; + #[link_name = "?minpos@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_minpos: *mut nsAtom; + #[link_name = "?minusSign@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_minusSign: *mut nsAtom; + #[link_name = "?minwidth@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_minwidth: *mut nsAtom; + #[link_name = "?_mixed@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__mixed: *mut nsAtom; + #[link_name = "?messagemanagergroup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_messagemanagergroup: *mut nsAtom; + #[link_name = "?mod@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mod: *mut nsAtom; + #[link_name = "?mode@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mode: *mut nsAtom; + #[link_name = "?modifiers@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_modifiers: *mut nsAtom; + #[link_name = "?monochrome@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_monochrome: *mut nsAtom; + #[link_name = "?mousedown@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mousedown: *mut nsAtom; + #[link_name = "?mousemove@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mousemove: *mut nsAtom; + #[link_name = "?mouseout@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mouseout: *mut nsAtom; + #[link_name = "?mouseover@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mouseover: *mut nsAtom; + #[link_name = "?mousethrough@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mousethrough: *mut nsAtom; + #[link_name = "?mouseup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mouseup: *mut nsAtom; + #[link_name = "?mozfullscreenchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozfullscreenchange: *mut nsAtom; + #[link_name = "?mozfullscreenerror@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozfullscreenerror: *mut nsAtom; + #[link_name = "?mozpointerlockchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozpointerlockchange: *mut nsAtom; + #[link_name = "?mozpointerlockerror@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozpointerlockerror: *mut nsAtom; + #[link_name = "?mozprivatebrowsing@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozprivatebrowsing: *mut nsAtom; + #[link_name = "?moz_opaque@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_moz_opaque: *mut nsAtom; + #[link_name = "?moz_action_hint@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_moz_action_hint: *mut nsAtom; + #[link_name = "?x_moz_errormessage@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x_moz_errormessage: *mut nsAtom; + #[link_name = "?multicol@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_multicol: *mut nsAtom; + #[link_name = "?multiple@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_multiple: *mut nsAtom; + #[link_name = "?muted@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_muted: *mut nsAtom; + #[link_name = "?name@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_name: *mut nsAtom; + #[link_name = "?_namespace@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__namespace: *mut nsAtom; + #[link_name = "?namespaceAlias@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_namespaceAlias: *mut nsAtom; + #[link_name = "?namespaceUri@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_namespaceUri: *mut nsAtom; + #[link_name = "?NaN@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_NaN: *mut nsAtom; + #[link_name = "?nativeAnonymousChildList@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nativeAnonymousChildList: *mut nsAtom; + #[link_name = "?nav@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nav: *mut nsAtom; + #[link_name = "?negate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_negate: *mut nsAtom; + #[link_name = "?never@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_never: *mut nsAtom; + #[link_name = "?_new@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__new: *mut nsAtom; + #[link_name = "?newline@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_newline: *mut nsAtom; + #[link_name = "?nextBidi@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nextBidi: *mut nsAtom; + #[link_name = "?nextTabParentId@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nextTabParentId: *mut nsAtom; + #[link_name = "?no@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_no: *mut nsAtom; + #[link_name = "?noautofocus@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_noautofocus: *mut nsAtom; + #[link_name = "?noautohide@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_noautohide: *mut nsAtom; + #[link_name = "?norolluponanchor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_norolluponanchor: *mut nsAtom; + #[link_name = "?nobr@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nobr: *mut nsAtom; + #[link_name = "?node@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_node: *mut nsAtom; + #[link_name = "?nodefaultsrc@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nodefaultsrc: *mut nsAtom; + #[link_name = "?nodeSet@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nodeSet: *mut nsAtom; + #[link_name = "?noembed@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_noembed: *mut nsAtom; + #[link_name = "?noframes@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_noframes: *mut nsAtom; + #[link_name = "?nohref@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nohref: *mut nsAtom; + #[link_name = "?noisolation@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_noisolation: *mut nsAtom; + #[link_name = "?nomodule@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nomodule: *mut nsAtom; + #[link_name = "?nonce@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nonce: *mut nsAtom; + #[link_name = "?none@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_none: *mut nsAtom; + #[link_name = "?noresize@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_noresize: *mut nsAtom; + #[link_name = "?normal@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_normal: *mut nsAtom; + #[link_name = "?normalizeSpace@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_normalizeSpace: *mut nsAtom; + #[link_name = "?noscript@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_noscript: *mut nsAtom; + #[link_name = "?noshade@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_noshade: *mut nsAtom; + #[link_name = "?novalidate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_novalidate: *mut nsAtom; + #[link_name = "?_not@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__not: *mut nsAtom; + #[link_name = "?nowrap@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nowrap: *mut nsAtom; + #[link_name = "?number@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_number: *mut nsAtom; + #[link_name = "?null@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_null: *mut nsAtom; + #[link_name = "?object@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_object: *mut nsAtom; + #[link_name = "?objectType@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_objectType: *mut nsAtom; + #[link_name = "?observer@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_observer: *mut nsAtom; + #[link_name = "?observes@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_observes: *mut nsAtom; + #[link_name = "?odd@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_odd: *mut nsAtom; + #[link_name = "?OFF@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_OFF: *mut nsAtom; + #[link_name = "?ol@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ol: *mut nsAtom; + #[link_name = "?omitXmlDeclaration@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_omitXmlDeclaration: *mut nsAtom; + #[link_name = "?ona2dpstatuschanged@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ona2dpstatuschanged: *mut nsAtom; + #[link_name = "?onabort@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onabort: *mut nsAtom; + #[link_name = "?onmozaccesskeynotfound@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmozaccesskeynotfound: *mut nsAtom; + #[link_name = "?onactivate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onactivate: *mut nsAtom; + #[link_name = "?onadapteradded@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onadapteradded: *mut nsAtom; + #[link_name = "?onadapterremoved@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onadapterremoved: *mut nsAtom; + #[link_name = "?onafterprint@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onafterprint: *mut nsAtom; + #[link_name = "?onafterscriptexecute@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onafterscriptexecute: *mut nsAtom; + #[link_name = "?onalerting@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onalerting: *mut nsAtom; + #[link_name = "?onanimationcancel@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onanimationcancel: *mut nsAtom; + #[link_name = "?onanimationend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onanimationend: *mut nsAtom; + #[link_name = "?onanimationiteration@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onanimationiteration: *mut nsAtom; + #[link_name = "?onanimationstart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onanimationstart: *mut nsAtom; + #[link_name = "?onantennaavailablechange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onantennaavailablechange: *mut nsAtom; + #[link_name = "?onAppCommand@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onAppCommand: *mut nsAtom; + #[link_name = "?onappinstalled@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onappinstalled: *mut nsAtom; + #[link_name = "?onattributechanged@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onattributechanged: *mut nsAtom; + #[link_name = "?onattributereadreq@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onattributereadreq: *mut nsAtom; + #[link_name = "?onattributewritereq@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onattributewritereq: *mut nsAtom; + #[link_name = "?onaudioprocess@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onaudioprocess: *mut nsAtom; + #[link_name = "?onauxclick@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onauxclick: *mut nsAtom; + #[link_name = "?onbeforecopy@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onbeforecopy: *mut nsAtom; + #[link_name = "?onbeforecut@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onbeforecut: *mut nsAtom; + #[link_name = "?onbeforepaste@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onbeforepaste: *mut nsAtom; + #[link_name = "?onbeforeevicted@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onbeforeevicted: *mut nsAtom; + #[link_name = "?onbeforeprint@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onbeforeprint: *mut nsAtom; + #[link_name = "?onbeforescriptexecute@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onbeforescriptexecute: *mut nsAtom; + #[link_name = "?onbeforeunload@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onbeforeunload: *mut nsAtom; + #[link_name = "?onblocked@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onblocked: *mut nsAtom; + #[link_name = "?onblur@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onblur: *mut nsAtom; + #[link_name = "?onbroadcast@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onbroadcast: *mut nsAtom; + #[link_name = "?onbusy@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onbusy: *mut nsAtom; + #[link_name = "?onbufferedamountlow@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onbufferedamountlow: *mut nsAtom; + #[link_name = "?oncached@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncached: *mut nsAtom; + #[link_name = "?oncallschanged@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncallschanged: *mut nsAtom; + #[link_name = "?oncancel@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncancel: *mut nsAtom; + #[link_name = "?oncardstatechange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncardstatechange: *mut nsAtom; + #[link_name = "?oncfstatechange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncfstatechange: *mut nsAtom; + #[link_name = "?onchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onchange: *mut nsAtom; + #[link_name = "?oncharacteristicchanged@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncharacteristicchanged: *mut nsAtom; + #[link_name = "?onchargingchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onchargingchange: *mut nsAtom; + #[link_name = "?onchargingtimechange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onchargingtimechange: *mut nsAtom; + #[link_name = "?onchecking@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onchecking: *mut nsAtom; + #[link_name = "?onCheckboxStateChange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onCheckboxStateChange: *mut nsAtom; + #[link_name = "?onclick@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onclick: *mut nsAtom; + #[link_name = "?onclirmodechange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onclirmodechange: *mut nsAtom; + #[link_name = "?onclose@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onclose: *mut nsAtom; + #[link_name = "?oncommand@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncommand: *mut nsAtom; + #[link_name = "?oncommandupdate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncommandupdate: *mut nsAtom; + #[link_name = "?oncomplete@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncomplete: *mut nsAtom; + #[link_name = "?oncompositionend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncompositionend: *mut nsAtom; + #[link_name = "?oncompositionstart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncompositionstart: *mut nsAtom; + #[link_name = "?oncompositionupdate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncompositionupdate: *mut nsAtom; + #[link_name = "?onconnect@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onconnect: *mut nsAtom; + #[link_name = "?onconnected@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onconnected: *mut nsAtom; + #[link_name = "?onconnecting@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onconnecting: *mut nsAtom; + #[link_name = "?onconnectionavailable@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onconnectionavailable: *mut nsAtom; + #[link_name = "?onconnectionstatechanged@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onconnectionstatechanged: *mut nsAtom; + #[link_name = "?oncontextmenu@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncontextmenu: *mut nsAtom; + #[link_name = "?oncopy@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncopy: *mut nsAtom; + #[link_name = "?oncurrentchannelchanged@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncurrentchannelchanged: *mut nsAtom; + #[link_name = "?oncurrentsourcechanged@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncurrentsourcechanged: *mut nsAtom; + #[link_name = "?oncut@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncut: *mut nsAtom; + #[link_name = "?ondatachange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondatachange: *mut nsAtom; + #[link_name = "?ondataerror@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondataerror: *mut nsAtom; + #[link_name = "?ondblclick@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondblclick: *mut nsAtom; + #[link_name = "?ondeleted@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondeleted: *mut nsAtom; + #[link_name = "?ondeliverysuccess@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondeliverysuccess: *mut nsAtom; + #[link_name = "?ondeliveryerror@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondeliveryerror: *mut nsAtom; + #[link_name = "?ondevicefound@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondevicefound: *mut nsAtom; + #[link_name = "?ondevicepaired@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondevicepaired: *mut nsAtom; + #[link_name = "?ondeviceunpaired@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondeviceunpaired: *mut nsAtom; + #[link_name = "?ondialing@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondialing: *mut nsAtom; + #[link_name = "?ondisabled@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondisabled: *mut nsAtom; + #[link_name = "?ondischargingtimechange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondischargingtimechange: *mut nsAtom; + #[link_name = "?ondisconnect@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondisconnect: *mut nsAtom; + #[link_name = "?ondisconnected@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondisconnected: *mut nsAtom; + #[link_name = "?ondisconnecting@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondisconnecting: *mut nsAtom; + #[link_name = "?ondisplaypasskeyreq@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondisplaypasskeyreq: *mut nsAtom; + #[link_name = "?ondownloading@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondownloading: *mut nsAtom; + #[link_name = "?onDOMActivate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onDOMActivate: *mut nsAtom; + #[link_name = "?onDOMAttrModified@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onDOMAttrModified: *mut nsAtom; + #[link_name = "?onDOMCharacterDataModified@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onDOMCharacterDataModified: *mut nsAtom; + #[link_name = "?onDOMFocusIn@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onDOMFocusIn: *mut nsAtom; + #[link_name = "?onDOMFocusOut@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onDOMFocusOut: *mut nsAtom; + #[link_name = "?onDOMMouseScroll@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onDOMMouseScroll: *mut nsAtom; + #[link_name = "?onDOMNodeInserted@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onDOMNodeInserted: *mut nsAtom; + #[link_name = "?onDOMNodeInsertedIntoDocument@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onDOMNodeInsertedIntoDocument: *mut nsAtom; + #[link_name = "?onDOMNodeRemoved@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onDOMNodeRemoved: *mut nsAtom; + #[link_name = "?onDOMNodeRemovedFromDocument@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onDOMNodeRemovedFromDocument: *mut nsAtom; + #[link_name = "?onDOMSubtreeModified@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onDOMSubtreeModified: *mut nsAtom; + #[link_name = "?ondata@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondata: *mut nsAtom; + #[link_name = "?ondrag@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondrag: *mut nsAtom; + #[link_name = "?ondragdrop@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondragdrop: *mut nsAtom; + #[link_name = "?ondragend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondragend: *mut nsAtom; + #[link_name = "?ondragenter@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondragenter: *mut nsAtom; + #[link_name = "?ondragexit@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondragexit: *mut nsAtom; + #[link_name = "?ondraggesture@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondraggesture: *mut nsAtom; + #[link_name = "?ondragleave@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondragleave: *mut nsAtom; + #[link_name = "?ondragover@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondragover: *mut nsAtom; + #[link_name = "?ondragstart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondragstart: *mut nsAtom; + #[link_name = "?ondrain@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondrain: *mut nsAtom; + #[link_name = "?ondrop@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondrop: *mut nsAtom; + #[link_name = "?oneitbroadcasted@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oneitbroadcasted: *mut nsAtom; + #[link_name = "?onenabled@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onenabled: *mut nsAtom; + #[link_name = "?onenterpincodereq@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onenterpincodereq: *mut nsAtom; + #[link_name = "?onemergencycbmodechange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onemergencycbmodechange: *mut nsAtom; + #[link_name = "?onerror@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onerror: *mut nsAtom; + #[link_name = "?onevicted@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onevicted: *mut nsAtom; + #[link_name = "?onfailed@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onfailed: *mut nsAtom; + #[link_name = "?onfetch@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onfetch: *mut nsAtom; + #[link_name = "?onfinish@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onfinish: *mut nsAtom; + #[link_name = "?onfocus@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onfocus: *mut nsAtom; + #[link_name = "?onfocusin@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onfocusin: *mut nsAtom; + #[link_name = "?onfocusout@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onfocusout: *mut nsAtom; + #[link_name = "?onfrequencychange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onfrequencychange: *mut nsAtom; + #[link_name = "?onfullscreenchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onfullscreenchange: *mut nsAtom; + #[link_name = "?onfullscreenerror@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onfullscreenerror: *mut nsAtom; + #[link_name = "?onspeakerforcedchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onspeakerforcedchange: *mut nsAtom; + #[link_name = "?onget@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onget: *mut nsAtom; + #[link_name = "?ongroupchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ongroupchange: *mut nsAtom; + #[link_name = "?onhashchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onhashchange: *mut nsAtom; + #[link_name = "?onheadphoneschange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onheadphoneschange: *mut nsAtom; + #[link_name = "?onheld@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onheld: *mut nsAtom; + #[link_name = "?onhfpstatuschanged@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onhfpstatuschanged: *mut nsAtom; + #[link_name = "?onhidstatuschanged@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onhidstatuschanged: *mut nsAtom; + #[link_name = "?onholding@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onholding: *mut nsAtom; + #[link_name = "?oniccchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oniccchange: *mut nsAtom; + #[link_name = "?oniccdetected@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oniccdetected: *mut nsAtom; + #[link_name = "?oniccinfochange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oniccinfochange: *mut nsAtom; + #[link_name = "?oniccundetected@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oniccundetected: *mut nsAtom; + #[link_name = "?onincoming@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onincoming: *mut nsAtom; + #[link_name = "?oninput@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oninput: *mut nsAtom; + #[link_name = "?oninstall@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oninstall: *mut nsAtom; + #[link_name = "?oninvalid@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oninvalid: *mut nsAtom; + #[link_name = "?onkeydown@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onkeydown: *mut nsAtom; + #[link_name = "?onkeypress@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onkeypress: *mut nsAtom; + #[link_name = "?onkeyup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onkeyup: *mut nsAtom; + #[link_name = "?onlanguagechange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onlanguagechange: *mut nsAtom; + #[link_name = "?onlevelchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onlevelchange: *mut nsAtom; + #[link_name = "?onLoad@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onLoad: *mut nsAtom; + #[link_name = "?onload@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onload: *mut nsAtom; + #[link_name = "?onloading@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onloading: *mut nsAtom; + #[link_name = "?onloadingdone@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onloadingdone: *mut nsAtom; + #[link_name = "?onloadingerror@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onloadingerror: *mut nsAtom; + #[link_name = "?onpopstate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpopstate: *mut nsAtom; + #[link_name = "?only@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_only: *mut nsAtom; + #[link_name = "?onmessage@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmessage: *mut nsAtom; + #[link_name = "?onmessageerror@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmessageerror: *mut nsAtom; + #[link_name = "?onmousedown@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmousedown: *mut nsAtom; + #[link_name = "?onmouseenter@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmouseenter: *mut nsAtom; + #[link_name = "?onmouseleave@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmouseleave: *mut nsAtom; + #[link_name = "?onmouselongtap@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmouselongtap: *mut nsAtom; + #[link_name = "?onmousemove@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmousemove: *mut nsAtom; + #[link_name = "?onmouseout@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmouseout: *mut nsAtom; + #[link_name = "?onmouseover@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmouseover: *mut nsAtom; + #[link_name = "?onMozMouseHittest@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onMozMouseHittest: *mut nsAtom; + #[link_name = "?onmouseup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmouseup: *mut nsAtom; + #[link_name = "?onMozAfterPaint@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onMozAfterPaint: *mut nsAtom; + #[link_name = "?onmozfullscreenchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmozfullscreenchange: *mut nsAtom; + #[link_name = "?onmozfullscreenerror@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmozfullscreenerror: *mut nsAtom; + #[link_name = "?onmozkeydownonplugin@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmozkeydownonplugin: *mut nsAtom; + #[link_name = "?onmozkeyuponplugin@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmozkeyuponplugin: *mut nsAtom; + #[link_name = "?onmozpointerlockchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmozpointerlockchange: *mut nsAtom; + #[link_name = "?onmozpointerlockerror@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmozpointerlockerror: *mut nsAtom; + #[link_name = "?onMozMousePixelScroll@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onMozMousePixelScroll: *mut nsAtom; + #[link_name = "?onMozScrolledAreaChanged@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onMozScrolledAreaChanged: *mut nsAtom; + #[link_name = "?onmapfolderlistingreq@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmapfolderlistingreq: *mut nsAtom; + #[link_name = "?onmapmessageslistingreq@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmapmessageslistingreq: *mut nsAtom; + #[link_name = "?onmapgetmessagereq@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmapgetmessagereq: *mut nsAtom; + #[link_name = "?onmapsetmessagestatusreq@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmapsetmessagestatusreq: *mut nsAtom; + #[link_name = "?onmapsendmessagereq@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmapsendmessagereq: *mut nsAtom; + #[link_name = "?onmapmessageupdatereq@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmapmessageupdatereq: *mut nsAtom; + #[link_name = "?onnewrdsgroup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onnewrdsgroup: *mut nsAtom; + #[link_name = "?onnotificationclick@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onnotificationclick: *mut nsAtom; + #[link_name = "?onnotificationclose@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onnotificationclose: *mut nsAtom; + #[link_name = "?onnoupdate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onnoupdate: *mut nsAtom; + #[link_name = "?onobexpasswordreq@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onobexpasswordreq: *mut nsAtom; + #[link_name = "?onobsolete@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onobsolete: *mut nsAtom; + #[link_name = "?ononline@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ononline: *mut nsAtom; + #[link_name = "?onoffline@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onoffline: *mut nsAtom; + #[link_name = "?onopen@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onopen: *mut nsAtom; + #[link_name = "?onorientationchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onorientationchange: *mut nsAtom; + #[link_name = "?onotastatuschange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onotastatuschange: *mut nsAtom; + #[link_name = "?onoverflow@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onoverflow: *mut nsAtom; + #[link_name = "?onoverflowchanged@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onoverflowchanged: *mut nsAtom; + #[link_name = "?onpagehide@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpagehide: *mut nsAtom; + #[link_name = "?onpageshow@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpageshow: *mut nsAtom; + #[link_name = "?onpaint@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpaint: *mut nsAtom; + #[link_name = "?onpairingaborted@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpairingaborted: *mut nsAtom; + #[link_name = "?onpairingconfirmationreq@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpairingconfirmationreq: *mut nsAtom; + #[link_name = "?onpairingconsentreq@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpairingconsentreq: *mut nsAtom; + #[link_name = "?onpaste@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpaste: *mut nsAtom; + #[link_name = "?onpendingchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpendingchange: *mut nsAtom; + #[link_name = "?onpichange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpichange: *mut nsAtom; + #[link_name = "?onpointerlockchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpointerlockchange: *mut nsAtom; + #[link_name = "?onpointerlockerror@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpointerlockerror: *mut nsAtom; + #[link_name = "?onpopuphidden@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpopuphidden: *mut nsAtom; + #[link_name = "?onpopuphiding@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpopuphiding: *mut nsAtom; + #[link_name = "?onpopuppositioned@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpopuppositioned: *mut nsAtom; + #[link_name = "?onpopupshowing@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpopupshowing: *mut nsAtom; + #[link_name = "?onpopupshown@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpopupshown: *mut nsAtom; + #[link_name = "?onpullphonebookreq@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpullphonebookreq: *mut nsAtom; + #[link_name = "?onpullvcardentryreq@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpullvcardentryreq: *mut nsAtom; + #[link_name = "?onpullvcardlistingreq@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpullvcardlistingreq: *mut nsAtom; + #[link_name = "?onpush@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpush: *mut nsAtom; + #[link_name = "?onpushsubscriptionchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpushsubscriptionchange: *mut nsAtom; + #[link_name = "?onpschange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpschange: *mut nsAtom; + #[link_name = "?onptychange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onptychange: *mut nsAtom; + #[link_name = "?onradiostatechange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onradiostatechange: *mut nsAtom; + #[link_name = "?onRadioStateChange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onRadioStateChange: *mut nsAtom; + #[link_name = "?onrdsdisabled@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onrdsdisabled: *mut nsAtom; + #[link_name = "?onrdsenabled@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onrdsenabled: *mut nsAtom; + #[link_name = "?onreaderror@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onreaderror: *mut nsAtom; + #[link_name = "?onreadsuccess@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onreadsuccess: *mut nsAtom; + #[link_name = "?onready@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onready: *mut nsAtom; + #[link_name = "?onreadystatechange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onreadystatechange: *mut nsAtom; + #[link_name = "?onreceived@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onreceived: *mut nsAtom; + #[link_name = "?onremoteheld@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onremoteheld: *mut nsAtom; + #[link_name = "?onremoteresumed@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onremoteresumed: *mut nsAtom; + #[link_name = "?onrequestprogress@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onrequestprogress: *mut nsAtom; + #[link_name = "?onresourcetimingbufferfull@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onresourcetimingbufferfull: *mut nsAtom; + #[link_name = "?onresponseprogress@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onresponseprogress: *mut nsAtom; + #[link_name = "?onretrieving@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onretrieving: *mut nsAtom; + #[link_name = "?onRequest@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onRequest: *mut nsAtom; + #[link_name = "?onrequestmediaplaystatus@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onrequestmediaplaystatus: *mut nsAtom; + #[link_name = "?onreset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onreset: *mut nsAtom; + #[link_name = "?onresuming@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onresuming: *mut nsAtom; + #[link_name = "?onresize@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onresize: *mut nsAtom; + #[link_name = "?onrtchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onrtchange: *mut nsAtom; + #[link_name = "?onscanningstatechanged@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onscanningstatechanged: *mut nsAtom; + #[link_name = "?onscostatuschanged@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onscostatuschanged: *mut nsAtom; + #[link_name = "?onscroll@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onscroll: *mut nsAtom; + #[link_name = "?onselect@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onselect: *mut nsAtom; + #[link_name = "?onselectionchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onselectionchange: *mut nsAtom; + #[link_name = "?onselectstart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onselectstart: *mut nsAtom; + #[link_name = "?onsending@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onsending: *mut nsAtom; + #[link_name = "?onsent@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onsent: *mut nsAtom; + #[link_name = "?onset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onset: *mut nsAtom; + #[link_name = "?onshippingaddresschange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onshippingaddresschange: *mut nsAtom; + #[link_name = "?onshippingoptionchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onshippingoptionchange: *mut nsAtom; + #[link_name = "?onshow@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onshow: *mut nsAtom; + #[link_name = "?onstatechange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onstatechange: *mut nsAtom; + #[link_name = "?onstatuschanged@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onstatuschanged: *mut nsAtom; + #[link_name = "?onstkcommand@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onstkcommand: *mut nsAtom; + #[link_name = "?onstksessionend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onstksessionend: *mut nsAtom; + #[link_name = "?onstorage@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onstorage: *mut nsAtom; + #[link_name = "?onstorageareachanged@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onstorageareachanged: *mut nsAtom; + #[link_name = "?onsubmit@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onsubmit: *mut nsAtom; + #[link_name = "?onsuccess@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onsuccess: *mut nsAtom; + #[link_name = "?ontypechange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ontypechange: *mut nsAtom; + #[link_name = "?onterminate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onterminate: *mut nsAtom; + #[link_name = "?ontext@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ontext: *mut nsAtom; + #[link_name = "?ontoggle@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ontoggle: *mut nsAtom; + #[link_name = "?ontouchstart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ontouchstart: *mut nsAtom; + #[link_name = "?ontouchend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ontouchend: *mut nsAtom; + #[link_name = "?ontouchmove@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ontouchmove: *mut nsAtom; + #[link_name = "?ontouchcancel@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ontouchcancel: *mut nsAtom; + #[link_name = "?ontransitioncancel@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ontransitioncancel: *mut nsAtom; + #[link_name = "?ontransitionend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ontransitionend: *mut nsAtom; + #[link_name = "?ontransitionrun@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ontransitionrun: *mut nsAtom; + #[link_name = "?ontransitionstart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ontransitionstart: *mut nsAtom; + #[link_name = "?onunderflow@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onunderflow: *mut nsAtom; + #[link_name = "?onunload@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onunload: *mut nsAtom; + #[link_name = "?onupdatefound@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onupdatefound: *mut nsAtom; + #[link_name = "?onupdateready@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onupdateready: *mut nsAtom; + #[link_name = "?onupgradeneeded@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onupgradeneeded: *mut nsAtom; + #[link_name = "?onussdreceived@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onussdreceived: *mut nsAtom; + #[link_name = "?onversionchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onversionchange: *mut nsAtom; + #[link_name = "?onvisibilitychange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onvisibilitychange: *mut nsAtom; + #[link_name = "?onvoicechange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onvoicechange: *mut nsAtom; + #[link_name = "?onvoiceschanged@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onvoiceschanged: *mut nsAtom; + #[link_name = "?onvrdisplayactivate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onvrdisplayactivate: *mut nsAtom; + #[link_name = "?onvrdisplayconnect@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onvrdisplayconnect: *mut nsAtom; + #[link_name = "?onvrdisplaydeactivate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onvrdisplaydeactivate: *mut nsAtom; + #[link_name = "?onvrdisplaydisconnect@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onvrdisplaydisconnect: *mut nsAtom; + #[link_name = "?onvrdisplaypresentchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onvrdisplaypresentchange: *mut nsAtom; + #[link_name = "?onwebkitAnimationEnd@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onwebkitAnimationEnd: *mut nsAtom; + #[link_name = "?onwebkitAnimationIteration@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onwebkitAnimationIteration: *mut nsAtom; + #[link_name = "?onwebkitAnimationStart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onwebkitAnimationStart: *mut nsAtom; + #[link_name = "?onwebkitTransitionEnd@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onwebkitTransitionEnd: *mut nsAtom; + #[link_name = "?onwebkitanimationend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onwebkitanimationend: *mut nsAtom; + #[link_name = "?onwebkitanimationiteration@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onwebkitanimationiteration: *mut nsAtom; + #[link_name = "?onwebkitanimationstart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onwebkitanimationstart: *mut nsAtom; + #[link_name = "?onwebkittransitionend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onwebkittransitionend: *mut nsAtom; + #[link_name = "?onwebsocket@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onwebsocket: *mut nsAtom; + #[link_name = "?onwheel@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onwheel: *mut nsAtom; + #[link_name = "?open@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_open: *mut nsAtom; + #[link_name = "?optgroup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_optgroup: *mut nsAtom; + #[link_name = "?optimum@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_optimum: *mut nsAtom; + #[link_name = "?option@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_option: *mut nsAtom; + #[link_name = "?_or@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__or: *mut nsAtom; + #[link_name = "?order@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_order: *mut nsAtom; + #[link_name = "?ordinal@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ordinal: *mut nsAtom; + #[link_name = "?orient@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_orient: *mut nsAtom; + #[link_name = "?orientation@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_orientation: *mut nsAtom; + #[link_name = "?otherwise@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_otherwise: *mut nsAtom; + #[link_name = "?output@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_output: *mut nsAtom; + #[link_name = "?overflow@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_overflow: *mut nsAtom; + #[link_name = "?overflowchanged@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_overflowchanged: *mut nsAtom; + #[link_name = "?overlay@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_overlay: *mut nsAtom; + #[link_name = "?overlap@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_overlap: *mut nsAtom; + #[link_name = "?p@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_p: *mut nsAtom; + #[link_name = "?pack@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pack: *mut nsAtom; + #[link_name = "?page@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_page: *mut nsAtom; + #[link_name = "?pageincrement@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pageincrement: *mut nsAtom; + #[link_name = "?pagex@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pagex: *mut nsAtom; + #[link_name = "?pagey@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pagey: *mut nsAtom; + #[link_name = "?paint_order@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_paint_order: *mut nsAtom; + #[link_name = "?palettename@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_palettename: *mut nsAtom; + #[link_name = "?panel@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_panel: *mut nsAtom; + #[link_name = "?param@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_param: *mut nsAtom; + #[link_name = "?parameter@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_parameter: *mut nsAtom; + #[link_name = "?parent@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_parent: *mut nsAtom; + #[link_name = "?parentfocused@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_parentfocused: *mut nsAtom; + #[link_name = "?parsetype@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_parsetype: *mut nsAtom; + #[link_name = "?password@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_password: *mut nsAtom; + #[link_name = "?pattern@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pattern: *mut nsAtom; + #[link_name = "?patternSeparator@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_patternSeparator: *mut nsAtom; + #[link_name = "?perMille@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_perMille: *mut nsAtom; + #[link_name = "?percent@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_percent: *mut nsAtom; + #[link_name = "?persist@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_persist: *mut nsAtom; + #[link_name = "?phase@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_phase: *mut nsAtom; + #[link_name = "?picture@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_picture: *mut nsAtom; + #[link_name = "?ping@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ping: *mut nsAtom; + #[link_name = "?pinned@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pinned: *mut nsAtom; + #[link_name = "?placeholder@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_placeholder: *mut nsAtom; + #[link_name = "?plaintext@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_plaintext: *mut nsAtom; + #[link_name = "?playbackrate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_playbackrate: *mut nsAtom; + #[link_name = "?pointSize@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pointSize: *mut nsAtom; + #[link_name = "?pointerlockchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pointerlockchange: *mut nsAtom; + #[link_name = "?pointerlockerror@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pointerlockerror: *mut nsAtom; + #[link_name = "?poly@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_poly: *mut nsAtom; + #[link_name = "?polygon@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_polygon: *mut nsAtom; + #[link_name = "?popup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_popup: *mut nsAtom; + #[link_name = "?popupalign@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_popupalign: *mut nsAtom; + #[link_name = "?popupanchor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_popupanchor: *mut nsAtom; + #[link_name = "?popupgroup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_popupgroup: *mut nsAtom; + #[link_name = "?popuphidden@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_popuphidden: *mut nsAtom; + #[link_name = "?popuphiding@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_popuphiding: *mut nsAtom; + #[link_name = "?popupset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_popupset: *mut nsAtom; + #[link_name = "?popupshowing@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_popupshowing: *mut nsAtom; + #[link_name = "?popupshown@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_popupshown: *mut nsAtom; + #[link_name = "?popupsinherittooltip@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_popupsinherittooltip: *mut nsAtom; + #[link_name = "?position@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_position: *mut nsAtom; + #[link_name = "?poster@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_poster: *mut nsAtom; + #[link_name = "?pre@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pre: *mut nsAtom; + #[link_name = "?preceding@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_preceding: *mut nsAtom; + #[link_name = "?precedingSibling@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_precedingSibling: *mut nsAtom; + #[link_name = "?predicate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_predicate: *mut nsAtom; + #[link_name = "?prefix@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_prefix: *mut nsAtom; + #[link_name = "?preload@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_preload: *mut nsAtom; + #[link_name = "?prerendered@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_prerendered: *mut nsAtom; + #[link_name = "?mozpresentation@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozpresentation: *mut nsAtom; + #[link_name = "?preserve@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_preserve: *mut nsAtom; + #[link_name = "?preserveSpace@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_preserveSpace: *mut nsAtom; + #[link_name = "?preventdefault@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_preventdefault: *mut nsAtom; + #[link_name = "?primary@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_primary: *mut nsAtom; + #[link_name = "?print@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_print: *mut nsAtom; + #[link_name = "?priority@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_priority: *mut nsAtom; + #[link_name = "?processingInstruction@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_processingInstruction: *mut nsAtom; + #[link_name = "?profile@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_profile: *mut nsAtom; + #[link_name = "?progress@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_progress: *mut nsAtom; + #[link_name = "?progressmeter@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_progressmeter: *mut nsAtom; + #[link_name = "?progressNormal@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_progressNormal: *mut nsAtom; + #[link_name = "?progressUndetermined@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_progressUndetermined: *mut nsAtom; + #[link_name = "?projection@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_projection: *mut nsAtom; + #[link_name = "?prompt@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_prompt: *mut nsAtom; + #[link_name = "?propagate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_propagate: *mut nsAtom; + #[link_name = "?properties@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_properties: *mut nsAtom; + #[link_name = "?property@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_property: *mut nsAtom; + #[link_name = "?pubdate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pubdate: *mut nsAtom; + #[link_name = "?q@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_q: *mut nsAtom; + #[link_name = "?query@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_query: *mut nsAtom; + #[link_name = "?queryset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_queryset: *mut nsAtom; + #[link_name = "?querytype@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_querytype: *mut nsAtom; + #[link_name = "?radio@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_radio: *mut nsAtom; + #[link_name = "?radiogroup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_radiogroup: *mut nsAtom; + #[link_name = "?range@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_range: *mut nsAtom; + #[link_name = "?readonly@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_readonly: *mut nsAtom; + #[link_name = "?rect@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rect: *mut nsAtom; + #[link_name = "?rectangle@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rectangle: *mut nsAtom; + #[link_name = "?ref@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ref: *mut nsAtom; + #[link_name = "?refresh@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_refresh: *mut nsAtom; + #[link_name = "?rel@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rel: *mut nsAtom; + #[link_name = "?onreloadpage@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onreloadpage: *mut nsAtom; + #[link_name = "?rem@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rem: *mut nsAtom; + #[link_name = "?remote@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_remote: *mut nsAtom; + #[link_name = "?removeelement@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_removeelement: *mut nsAtom; + #[link_name = "?renderingobserverlist@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_renderingobserverlist: *mut nsAtom; + #[link_name = "?repeat@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_repeat: *mut nsAtom; + #[link_name = "?replace@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_replace: *mut nsAtom; + #[link_name = "?requestcontextid@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_requestcontextid: *mut nsAtom; + #[link_name = "?required@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_required: *mut nsAtom; + #[link_name = "?reserved@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_reserved: *mut nsAtom; + #[link_name = "?reset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_reset: *mut nsAtom; + #[link_name = "?resizeafter@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_resizeafter: *mut nsAtom; + #[link_name = "?resizebefore@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_resizebefore: *mut nsAtom; + #[link_name = "?resizer@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_resizer: *mut nsAtom; + #[link_name = "?resolution@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_resolution: *mut nsAtom; + #[link_name = "?resource@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_resource: *mut nsAtom; + #[link_name = "?resources@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_resources: *mut nsAtom; + #[link_name = "?result@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_result: *mut nsAtom; + #[link_name = "?resultPrefix@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_resultPrefix: *mut nsAtom; + #[link_name = "?retargetdocumentfocus@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_retargetdocumentfocus: *mut nsAtom; + #[link_name = "?rev@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rev: *mut nsAtom; + #[link_name = "?reverse@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_reverse: *mut nsAtom; + #[link_name = "?reversed@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_reversed: *mut nsAtom; + #[link_name = "?richlistbox@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_richlistbox: *mut nsAtom; + #[link_name = "?richlistitem@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_richlistitem: *mut nsAtom; + #[link_name = "?right@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_right: *mut nsAtom; + #[link_name = "?rightmargin@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rightmargin: *mut nsAtom; + #[link_name = "?rightpadding@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rightpadding: *mut nsAtom; + #[link_name = "?role@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_role: *mut nsAtom; + #[link_name = "?rolluponmousewheel@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rolluponmousewheel: *mut nsAtom; + #[link_name = "?round@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_round: *mut nsAtom; + #[link_name = "?row@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_row: *mut nsAtom; + #[link_name = "?rows@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rows: *mut nsAtom; + #[link_name = "?rowspan@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rowspan: *mut nsAtom; + #[link_name = "?rb@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rb: *mut nsAtom; + #[link_name = "?rp@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rp: *mut nsAtom; + #[link_name = "?rt@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rt: *mut nsAtom; + #[link_name = "?rtc@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rtc: *mut nsAtom; + #[link_name = "?rtl@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rtl: *mut nsAtom; + #[link_name = "?ruby@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ruby: *mut nsAtom; + #[link_name = "?rubyBase@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rubyBase: *mut nsAtom; + #[link_name = "?rubyBaseContainer@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rubyBaseContainer: *mut nsAtom; + #[link_name = "?rubyText@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rubyText: *mut nsAtom; + #[link_name = "?rubyTextContainer@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rubyTextContainer: *mut nsAtom; + #[link_name = "?rule@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rule: *mut nsAtom; + #[link_name = "?rules@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rules: *mut nsAtom; + #[link_name = "?s@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_s: *mut nsAtom; + #[link_name = "?samp@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_samp: *mut nsAtom; + #[link_name = "?sandbox@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sandbox: *mut nsAtom; + #[link_name = "?sbattr@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sbattr: *mut nsAtom; + #[link_name = "?scale@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scale: *mut nsAtom; + #[link_name = "?scan@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scan: *mut nsAtom; + #[link_name = "?scheme@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scheme: *mut nsAtom; + #[link_name = "?scope@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scope: *mut nsAtom; + #[link_name = "?scoped@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scoped: *mut nsAtom; + #[link_name = "?screen@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_screen: *mut nsAtom; + #[link_name = "?screenX@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_screenX: *mut nsAtom; + #[link_name = "?screenY@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_screenY: *mut nsAtom; + #[link_name = "?script@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_script: *mut nsAtom; + #[link_name = "?scriptEnabledBeforePrintOrPreview@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scriptEnabledBeforePrintOrPreview: *mut nsAtom; + #[link_name = "?scrollbar@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scrollbar: *mut nsAtom; + #[link_name = "?scrollbarbutton@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scrollbarbutton: *mut nsAtom; + #[link_name = "?scrollbarDownBottom@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scrollbarDownBottom: *mut nsAtom; + #[link_name = "?scrollbarDownTop@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scrollbarDownTop: *mut nsAtom; + #[link_name = "?scrollbarUpBottom@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scrollbarUpBottom: *mut nsAtom; + #[link_name = "?scrollbarUpTop@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scrollbarUpTop: *mut nsAtom; + #[link_name = "?scrollbox@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scrollbox: *mut nsAtom; + #[link_name = "?scrollcorner@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scrollcorner: *mut nsAtom; + #[link_name = "?scrolling@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scrolling: *mut nsAtom; + #[link_name = "?scrollPosition@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scrollPosition: *mut nsAtom; + #[link_name = "?section@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_section: *mut nsAtom; + #[link_name = "?select@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_select: *mut nsAtom; + #[link_name = "?selectable@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_selectable: *mut nsAtom; + #[link_name = "?selected@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_selected: *mut nsAtom; + #[link_name = "?selectedIndex@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_selectedIndex: *mut nsAtom; + #[link_name = "?selectedindex@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_selectedindex: *mut nsAtom; + #[link_name = "?self@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_self: *mut nsAtom; + #[link_name = "?seltype@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_seltype: *mut nsAtom; + #[link_name = "?setcookie@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_setcookie: *mut nsAtom; + #[link_name = "?setter@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_setter: *mut nsAtom; + #[link_name = "?shape@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_shape: *mut nsAtom; + #[link_name = "?show@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_show: *mut nsAtom; + #[link_name = "?showcaret@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_showcaret: *mut nsAtom; + #[link_name = "?showresizer@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_showresizer: *mut nsAtom; + #[link_name = "?simple@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_simple: *mut nsAtom; + #[link_name = "?simp_chinese_formal@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_simp_chinese_formal: *mut nsAtom; + #[link_name = "?simp_chinese_informal@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_simp_chinese_informal: *mut nsAtom; + #[link_name = "?single@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_single: *mut nsAtom; + #[link_name = "?size@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_size: *mut nsAtom; + #[link_name = "?sizes@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sizes: *mut nsAtom; + #[link_name = "?sizemode@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sizemode: *mut nsAtom; + #[link_name = "?sizetopopup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sizetopopup: *mut nsAtom; + #[link_name = "?slider@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_slider: *mut nsAtom; + #[link_name = "?small@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_small: *mut nsAtom; + #[link_name = "?smooth@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_smooth: *mut nsAtom; + #[link_name = "?snap@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_snap: *mut nsAtom; + #[link_name = "?sort@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sort: *mut nsAtom; + #[link_name = "?sortActive@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sortActive: *mut nsAtom; + #[link_name = "?sortDirection@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sortDirection: *mut nsAtom; + #[link_name = "?sorted@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sorted: *mut nsAtom; + #[link_name = "?sorthints@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sorthints: *mut nsAtom; + #[link_name = "?sortLocked@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sortLocked: *mut nsAtom; + #[link_name = "?sortResource@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sortResource: *mut nsAtom; + #[link_name = "?sortResource2@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sortResource2: *mut nsAtom; + #[link_name = "?sortSeparators@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sortSeparators: *mut nsAtom; + #[link_name = "?sortStaticsLast@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sortStaticsLast: *mut nsAtom; + #[link_name = "?source@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_source: *mut nsAtom; + #[link_name = "?space@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_space: *mut nsAtom; + #[link_name = "?spacer@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_spacer: *mut nsAtom; + #[link_name = "?span@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_span: *mut nsAtom; + #[link_name = "?spellcheck@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_spellcheck: *mut nsAtom; + #[link_name = "?spinner@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_spinner: *mut nsAtom; + #[link_name = "?split@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_split: *mut nsAtom; + #[link_name = "?splitter@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_splitter: *mut nsAtom; + #[link_name = "?spring@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_spring: *mut nsAtom; + #[link_name = "?square@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_square: *mut nsAtom; + #[link_name = "?src@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_src: *mut nsAtom; + #[link_name = "?srcdoc@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_srcdoc: *mut nsAtom; + #[link_name = "?srclang@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_srclang: *mut nsAtom; + #[link_name = "?srcset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_srcset: *mut nsAtom; + #[link_name = "?stack@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stack: *mut nsAtom; + #[link_name = "?standalone@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_standalone: *mut nsAtom; + #[link_name = "?standby@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_standby: *mut nsAtom; + #[link_name = "?start@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_start: *mut nsAtom; + #[link_name = "?start_after@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_start_after: *mut nsAtom; + #[link_name = "?start_before@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_start_before: *mut nsAtom; + #[link_name = "?startsWith@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_startsWith: *mut nsAtom; + #[link_name = "?state@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_state: *mut nsAtom; + #[link_name = "?statedatasource@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_statedatasource: *mut nsAtom; + #[link_name = "?staticHint@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_staticHint: *mut nsAtom; + #[link_name = "?statusbar@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_statusbar: *mut nsAtom; + #[link_name = "?statustext@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_statustext: *mut nsAtom; + #[link_name = "?step@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_step: *mut nsAtom; + #[link_name = "?stop@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stop: *mut nsAtom; + #[link_name = "?stretch@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stretch: *mut nsAtom; + #[link_name = "?strike@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_strike: *mut nsAtom; + #[link_name = "?string@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_string: *mut nsAtom; + #[link_name = "?stringLength@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stringLength: *mut nsAtom; + #[link_name = "?stripSpace@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stripSpace: *mut nsAtom; + #[link_name = "?strong@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_strong: *mut nsAtom; + #[link_name = "?style@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_style: *mut nsAtom; + #[link_name = "?stylesheet@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stylesheet: *mut nsAtom; + #[link_name = "?stylesheetPrefix@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stylesheetPrefix: *mut nsAtom; + #[link_name = "?subject@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_subject: *mut nsAtom; + #[link_name = "?submit@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_submit: *mut nsAtom; + #[link_name = "?substate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_substate: *mut nsAtom; + #[link_name = "?substring@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_substring: *mut nsAtom; + #[link_name = "?substringAfter@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_substringAfter: *mut nsAtom; + #[link_name = "?substringBefore@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_substringBefore: *mut nsAtom; + #[link_name = "?sub@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sub: *mut nsAtom; + #[link_name = "?sum@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sum: *mut nsAtom; + #[link_name = "?sup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sup: *mut nsAtom; + #[link_name = "?summary@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_summary: *mut nsAtom; + #[link_name = "?_switch@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__switch: *mut nsAtom; + #[link_name = "?systemProperty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_systemProperty: *mut nsAtom; + #[link_name = "?tab@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tab: *mut nsAtom; + #[link_name = "?tabbox@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tabbox: *mut nsAtom; + #[link_name = "?tabindex@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tabindex: *mut nsAtom; + #[link_name = "?table@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_table: *mut nsAtom; + #[link_name = "?tabpanel@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tabpanel: *mut nsAtom; + #[link_name = "?tabpanels@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tabpanels: *mut nsAtom; + #[link_name = "?tag@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tag: *mut nsAtom; + #[link_name = "?target@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_target: *mut nsAtom; + #[link_name = "?targets@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_targets: *mut nsAtom; + #[link_name = "?tbody@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tbody: *mut nsAtom; + #[link_name = "?td@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_td: *mut nsAtom; + #[link_name = "?_template@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__template: *mut nsAtom; + #[link_name = "?text_decoration@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_text_decoration: *mut nsAtom; + #[link_name = "?terminate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_terminate: *mut nsAtom; + #[link_name = "?term@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_term: *mut nsAtom; + #[link_name = "?test@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_test: *mut nsAtom; + #[link_name = "?text@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_text: *mut nsAtom; + #[link_name = "?textAlign@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_textAlign: *mut nsAtom; + #[link_name = "?textarea@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_textarea: *mut nsAtom; + #[link_name = "?textbox@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_textbox: *mut nsAtom; + #[link_name = "?textnode@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_textnode: *mut nsAtom; + #[link_name = "?textNodeDirectionalityMap@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_textNodeDirectionalityMap: *mut nsAtom; + #[link_name = "?tfoot@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tfoot: *mut nsAtom; + #[link_name = "?th@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_th: *mut nsAtom; + #[link_name = "?thead@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_thead: *mut nsAtom; + #[link_name = "?thumb@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_thumb: *mut nsAtom; + #[link_name = "?time@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_time: *mut nsAtom; + #[link_name = "?title@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_title: *mut nsAtom; + #[link_name = "?titlebar@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_titlebar: *mut nsAtom; + #[link_name = "?titletip@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_titletip: *mut nsAtom; + #[link_name = "?toggled@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_toggled: *mut nsAtom; + #[link_name = "?token@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_token: *mut nsAtom; + #[link_name = "?tokenize@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tokenize: *mut nsAtom; + #[link_name = "?toolbar@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_toolbar: *mut nsAtom; + #[link_name = "?toolbarbutton@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_toolbarbutton: *mut nsAtom; + #[link_name = "?toolbaritem@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_toolbaritem: *mut nsAtom; + #[link_name = "?toolbox@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_toolbox: *mut nsAtom; + #[link_name = "?tooltip@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tooltip: *mut nsAtom; + #[link_name = "?tooltiptext@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tooltiptext: *mut nsAtom; + #[link_name = "?top@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_top: *mut nsAtom; + #[link_name = "?topleft@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_topleft: *mut nsAtom; + #[link_name = "?topmargin@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_topmargin: *mut nsAtom; + #[link_name = "?toppadding@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_toppadding: *mut nsAtom; + #[link_name = "?topright@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_topright: *mut nsAtom; + #[link_name = "?tr@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tr: *mut nsAtom; + #[link_name = "?track@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_track: *mut nsAtom; + #[link_name = "?trad_chinese_formal@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_trad_chinese_formal: *mut nsAtom; + #[link_name = "?trad_chinese_informal@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_trad_chinese_informal: *mut nsAtom; + #[link_name = "?trailing@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_trailing: *mut nsAtom; + #[link_name = "?transform@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_transform: *mut nsAtom; + #[link_name = "?transform_3d@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_transform_3d: *mut nsAtom; + #[link_name = "?transformiix@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_transformiix: *mut nsAtom; + #[link_name = "?translate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_translate: *mut nsAtom; + #[link_name = "?transparent@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_transparent: *mut nsAtom; + #[link_name = "?tree@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tree: *mut nsAtom; + #[link_name = "?treecell@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_treecell: *mut nsAtom; + #[link_name = "?treechildren@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_treechildren: *mut nsAtom; + #[link_name = "?treecol@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_treecol: *mut nsAtom; + #[link_name = "?treecolpicker@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_treecolpicker: *mut nsAtom; + #[link_name = "?treecols@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_treecols: *mut nsAtom; + #[link_name = "?treeitem@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_treeitem: *mut nsAtom; + #[link_name = "?treerow@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_treerow: *mut nsAtom; + #[link_name = "?treeseparator@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_treeseparator: *mut nsAtom; + #[link_name = "?triple@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_triple: *mut nsAtom; + #[link_name = "?_true@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__true: *mut nsAtom; + #[link_name = "?tt@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tt: *mut nsAtom; + #[link_name = "?tty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tty: *mut nsAtom; + #[link_name = "?tv@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tv: *mut nsAtom; + #[link_name = "?type@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_type: *mut nsAtom; + #[link_name = "?typemustmatch@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_typemustmatch: *mut nsAtom; + #[link_name = "?u@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_u: *mut nsAtom; + #[link_name = "?ul@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ul: *mut nsAtom; + #[link_name = "?underflow@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_underflow: *mut nsAtom; + #[link_name = "?undetermined@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_undetermined: *mut nsAtom; + #[link_name = "?unload@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_unload: *mut nsAtom; + #[link_name = "?unparsedEntityUri@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_unparsedEntityUri: *mut nsAtom; + #[link_name = "?upperAlpha@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_upperAlpha: *mut nsAtom; + #[link_name = "?upperFirst@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_upperFirst: *mut nsAtom; + #[link_name = "?upperRoman@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_upperRoman: *mut nsAtom; + #[link_name = "?uri@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_uri: *mut nsAtom; + #[link_name = "?use@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_use: *mut nsAtom; + #[link_name = "?useAttributeSets@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_useAttributeSets: *mut nsAtom; + #[link_name = "?usemap@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_usemap: *mut nsAtom; + #[link_name = "?user_scalable@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_user_scalable: *mut nsAtom; + #[link_name = "?userInput@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_userInput: *mut nsAtom; + #[link_name = "?validate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_validate: *mut nsAtom; + #[link_name = "?valign@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_valign: *mut nsAtom; + #[link_name = "?value@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_value: *mut nsAtom; + #[link_name = "?values@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_values: *mut nsAtom; + #[link_name = "?valueOf@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_valueOf: *mut nsAtom; + #[link_name = "?valuetype@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_valuetype: *mut nsAtom; + #[link_name = "?var@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_var: *mut nsAtom; + #[link_name = "?variable@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_variable: *mut nsAtom; + #[link_name = "?vbox@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_vbox: *mut nsAtom; + #[link_name = "?vcard_name@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_vcard_name: *mut nsAtom; + #[link_name = "?vendor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_vendor: *mut nsAtom; + #[link_name = "?vendorUrl@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_vendorUrl: *mut nsAtom; + #[link_name = "?version@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_version: *mut nsAtom; + #[link_name = "?vert@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_vert: *mut nsAtom; + #[link_name = "?vertical@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_vertical: *mut nsAtom; + #[link_name = "?audio@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_audio: *mut nsAtom; + #[link_name = "?video@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_video: *mut nsAtom; + #[link_name = "?videocontrols@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_videocontrols: *mut nsAtom; + #[link_name = "?viewport@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_viewport: *mut nsAtom; + #[link_name = "?viewport_height@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_viewport_height: *mut nsAtom; + #[link_name = "?viewport_initial_scale@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_viewport_initial_scale: *mut nsAtom; + #[link_name = "?viewport_maximum_scale@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_viewport_maximum_scale: *mut nsAtom; + #[link_name = "?viewport_minimum_scale@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_viewport_minimum_scale: *mut nsAtom; + #[link_name = "?viewport_user_scalable@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_viewport_user_scalable: *mut nsAtom; + #[link_name = "?viewport_width@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_viewport_width: *mut nsAtom; + #[link_name = "?visibility@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_visibility: *mut nsAtom; + #[link_name = "?visuallyselected@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_visuallyselected: *mut nsAtom; + #[link_name = "?vlink@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_vlink: *mut nsAtom; + #[link_name = "?vspace@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_vspace: *mut nsAtom; + #[link_name = "?wbr@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_wbr: *mut nsAtom; + #[link_name = "?webkitdirectory@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_webkitdirectory: *mut nsAtom; + #[link_name = "?when@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_when: *mut nsAtom; + #[link_name = "?where@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_where: *mut nsAtom; + #[link_name = "?widget@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_widget: *mut nsAtom; + #[link_name = "?width@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_width: *mut nsAtom; + #[link_name = "?willChange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_willChange: *mut nsAtom; + #[link_name = "?window@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_window: *mut nsAtom; + #[link_name = "?headerWindowTarget@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_headerWindowTarget: *mut nsAtom; + #[link_name = "?windowtype@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_windowtype: *mut nsAtom; + #[link_name = "?withParam@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_withParam: *mut nsAtom; + #[link_name = "?wizard@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_wizard: *mut nsAtom; + #[link_name = "?wrap@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_wrap: *mut nsAtom; + #[link_name = "?headerDNSPrefetchControl@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_headerDNSPrefetchControl: *mut nsAtom; + #[link_name = "?headerCSP@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_headerCSP: *mut nsAtom; + #[link_name = "?headerCSPReportOnly@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_headerCSPReportOnly: *mut nsAtom; + #[link_name = "?headerXFO@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_headerXFO: *mut nsAtom; + #[link_name = "?x_western@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x_western: *mut nsAtom; + #[link_name = "?xml@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xml: *mut nsAtom; + #[link_name = "?xml_stylesheet@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xml_stylesheet: *mut nsAtom; + #[link_name = "?xmlns@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xmlns: *mut nsAtom; + #[link_name = "?xmp@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xmp: *mut nsAtom; + #[link_name = "?xulcontentsgenerated@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xulcontentsgenerated: *mut nsAtom; + #[link_name = "?yes@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_yes: *mut nsAtom; + #[link_name = "?z_index@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_z_index: *mut nsAtom; + #[link_name = "?zeroDigit@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_zeroDigit: *mut nsAtom; + #[link_name = "?percentage@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_percentage: *mut nsAtom; + #[link_name = "?A@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_A: *mut nsAtom; + #[link_name = "?alignment_baseline@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_alignment_baseline: *mut nsAtom; + #[link_name = "?amplitude@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_amplitude: *mut nsAtom; + #[link_name = "?animate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_animate: *mut nsAtom; + #[link_name = "?animateColor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_animateColor: *mut nsAtom; + #[link_name = "?animateMotion@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_animateMotion: *mut nsAtom; + #[link_name = "?animateTransform@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_animateTransform: *mut nsAtom; + #[link_name = "?arithmetic@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_arithmetic: *mut nsAtom; + #[link_name = "?atop@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_atop: *mut nsAtom; + #[link_name = "?azimuth@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_azimuth: *mut nsAtom; + #[link_name = "?B@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_B: *mut nsAtom; + #[link_name = "?backgroundColor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_backgroundColor: *mut nsAtom; + #[link_name = "?background_image@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_background_image: *mut nsAtom; + #[link_name = "?baseFrequency@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_baseFrequency: *mut nsAtom; + #[link_name = "?baseline_shift@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_baseline_shift: *mut nsAtom; + #[link_name = "?bias@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_bias: *mut nsAtom; + #[link_name = "?caption_side@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_caption_side: *mut nsAtom; + #[link_name = "?clip_path@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_clip_path: *mut nsAtom; + #[link_name = "?clip_rule@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_clip_rule: *mut nsAtom; + #[link_name = "?clipPath@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_clipPath: *mut nsAtom; + #[link_name = "?clipPathUnits@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_clipPathUnits: *mut nsAtom; + #[link_name = "?cm@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cm: *mut nsAtom; + #[link_name = "?colorBurn@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_colorBurn: *mut nsAtom; + #[link_name = "?colorDodge@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_colorDodge: *mut nsAtom; + #[link_name = "?colorInterpolation@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_colorInterpolation: *mut nsAtom; + #[link_name = "?colorInterpolationFilters@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_colorInterpolationFilters: *mut nsAtom; + #[link_name = "?colorProfile@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_colorProfile: *mut nsAtom; + #[link_name = "?cursor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cursor: *mut nsAtom; + #[link_name = "?cx@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cx: *mut nsAtom; + #[link_name = "?cy@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cy: *mut nsAtom; + #[link_name = "?d@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_d: *mut nsAtom; + #[link_name = "?darken@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_darken: *mut nsAtom; + #[link_name = "?defs@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_defs: *mut nsAtom; + #[link_name = "?deg@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_deg: *mut nsAtom; + #[link_name = "?desc@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_desc: *mut nsAtom; + #[link_name = "?diffuseConstant@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_diffuseConstant: *mut nsAtom; + #[link_name = "?dilate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dilate: *mut nsAtom; + #[link_name = "?direction@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_direction: *mut nsAtom; + #[link_name = "?disable@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_disable: *mut nsAtom; + #[link_name = "?disc@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_disc: *mut nsAtom; + #[link_name = "?discrete@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_discrete: *mut nsAtom; + #[link_name = "?divisor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_divisor: *mut nsAtom; + #[link_name = "?dominant_baseline@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dominant_baseline: *mut nsAtom; + #[link_name = "?duplicate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_duplicate: *mut nsAtom; + #[link_name = "?dx@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dx: *mut nsAtom; + #[link_name = "?dy@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dy: *mut nsAtom; + #[link_name = "?edgeMode@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_edgeMode: *mut nsAtom; + #[link_name = "?ellipse@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ellipse: *mut nsAtom; + #[link_name = "?elevation@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_elevation: *mut nsAtom; + #[link_name = "?erode@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_erode: *mut nsAtom; + #[link_name = "?ex@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ex: *mut nsAtom; + #[link_name = "?exact@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_exact: *mut nsAtom; + #[link_name = "?exclusion@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_exclusion: *mut nsAtom; + #[link_name = "?exponent@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_exponent: *mut nsAtom; + #[link_name = "?feBlend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feBlend: *mut nsAtom; + #[link_name = "?feColorMatrix@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feColorMatrix: *mut nsAtom; + #[link_name = "?feComponentTransfer@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feComponentTransfer: *mut nsAtom; + #[link_name = "?feComposite@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feComposite: *mut nsAtom; + #[link_name = "?feConvolveMatrix@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feConvolveMatrix: *mut nsAtom; + #[link_name = "?feDiffuseLighting@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feDiffuseLighting: *mut nsAtom; + #[link_name = "?feDisplacementMap@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feDisplacementMap: *mut nsAtom; + #[link_name = "?feDistantLight@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feDistantLight: *mut nsAtom; + #[link_name = "?feDropShadow@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feDropShadow: *mut nsAtom; + #[link_name = "?feFlood@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feFlood: *mut nsAtom; + #[link_name = "?feFuncA@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feFuncA: *mut nsAtom; + #[link_name = "?feFuncB@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feFuncB: *mut nsAtom; + #[link_name = "?feFuncG@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feFuncG: *mut nsAtom; + #[link_name = "?feFuncR@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feFuncR: *mut nsAtom; + #[link_name = "?feGaussianBlur@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feGaussianBlur: *mut nsAtom; + #[link_name = "?feImage@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feImage: *mut nsAtom; + #[link_name = "?feMerge@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feMerge: *mut nsAtom; + #[link_name = "?feMergeNode@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feMergeNode: *mut nsAtom; + #[link_name = "?feMorphology@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feMorphology: *mut nsAtom; + #[link_name = "?feOffset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feOffset: *mut nsAtom; + #[link_name = "?fePointLight@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fePointLight: *mut nsAtom; + #[link_name = "?feSpecularLighting@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feSpecularLighting: *mut nsAtom; + #[link_name = "?feSpotLight@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feSpotLight: *mut nsAtom; + #[link_name = "?feTile@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feTile: *mut nsAtom; + #[link_name = "?feTurbulence@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feTurbulence: *mut nsAtom; + #[link_name = "?fill@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fill: *mut nsAtom; + #[link_name = "?fill_opacity@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fill_opacity: *mut nsAtom; + #[link_name = "?fill_rule@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fill_rule: *mut nsAtom; + #[link_name = "?filter@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_filter: *mut nsAtom; + #[link_name = "?filterUnits@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_filterUnits: *mut nsAtom; + #[link_name = "?_float@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__float: *mut nsAtom; + #[link_name = "?flood_color@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_flood_color: *mut nsAtom; + #[link_name = "?flood_opacity@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_flood_opacity: *mut nsAtom; + #[link_name = "?font_face@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_font_face: *mut nsAtom; + #[link_name = "?font_face_format@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_font_face_format: *mut nsAtom; + #[link_name = "?font_face_name@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_font_face_name: *mut nsAtom; + #[link_name = "?font_face_src@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_font_face_src: *mut nsAtom; + #[link_name = "?font_face_uri@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_font_face_uri: *mut nsAtom; + #[link_name = "?font_family@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_font_family: *mut nsAtom; + #[link_name = "?font_size@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_font_size: *mut nsAtom; + #[link_name = "?font_size_adjust@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_font_size_adjust: *mut nsAtom; + #[link_name = "?font_stretch@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_font_stretch: *mut nsAtom; + #[link_name = "?font_style@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_font_style: *mut nsAtom; + #[link_name = "?font_variant@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_font_variant: *mut nsAtom; + #[link_name = "?foreignObject@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_foreignObject: *mut nsAtom; + #[link_name = "?fractalNoise@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fractalNoise: *mut nsAtom; + #[link_name = "?fr@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fr: *mut nsAtom; + #[link_name = "?fx@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fx: *mut nsAtom; + #[link_name = "?fy@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fy: *mut nsAtom; + #[link_name = "?G@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_G: *mut nsAtom; + #[link_name = "?g@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_g: *mut nsAtom; + #[link_name = "?gamma@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_gamma: *mut nsAtom; + #[link_name = "?generic_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_generic_: *mut nsAtom; + #[link_name = "?glyphRef@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_glyphRef: *mut nsAtom; + #[link_name = "?grad@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_grad: *mut nsAtom; + #[link_name = "?gradientTransform@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_gradientTransform: *mut nsAtom; + #[link_name = "?gradientUnits@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_gradientUnits: *mut nsAtom; + #[link_name = "?hardLight@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_hardLight: *mut nsAtom; + #[link_name = "?hue@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_hue: *mut nsAtom; + #[link_name = "?hueRotate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_hueRotate: *mut nsAtom; + #[link_name = "?identity@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_identity: *mut nsAtom; + #[link_name = "?image_rendering@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_image_rendering: *mut nsAtom; + #[link_name = "?in@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_in: *mut nsAtom; + #[link_name = "?in2@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_in2: *mut nsAtom; + #[link_name = "?intercept@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_intercept: *mut nsAtom; + #[link_name = "?k1@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_k1: *mut nsAtom; + #[link_name = "?k2@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_k2: *mut nsAtom; + #[link_name = "?k3@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_k3: *mut nsAtom; + #[link_name = "?k4@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_k4: *mut nsAtom; + #[link_name = "?kernelMatrix@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_kernelMatrix: *mut nsAtom; + #[link_name = "?kernelUnitLength@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_kernelUnitLength: *mut nsAtom; + #[link_name = "?lengthAdjust@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lengthAdjust: *mut nsAtom; + #[link_name = "?letter_spacing@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_letter_spacing: *mut nsAtom; + #[link_name = "?lighten@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lighten: *mut nsAtom; + #[link_name = "?lighting_color@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lighting_color: *mut nsAtom; + #[link_name = "?limitingConeAngle@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_limitingConeAngle: *mut nsAtom; + #[link_name = "?linear@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_linear: *mut nsAtom; + #[link_name = "?linearGradient@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_linearGradient: *mut nsAtom; + #[link_name = "?linearRGB@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_linearRGB: *mut nsAtom; + #[link_name = "?list_style_type@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_list_style_type: *mut nsAtom; + #[link_name = "?luminanceToAlpha@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_luminanceToAlpha: *mut nsAtom; + #[link_name = "?luminosity@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_luminosity: *mut nsAtom; + #[link_name = "?magnify@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_magnify: *mut nsAtom; + #[link_name = "?marker@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_marker: *mut nsAtom; + #[link_name = "?marker_end@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_marker_end: *mut nsAtom; + #[link_name = "?marker_mid@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_marker_mid: *mut nsAtom; + #[link_name = "?marker_start@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_marker_start: *mut nsAtom; + #[link_name = "?markerHeight@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_markerHeight: *mut nsAtom; + #[link_name = "?markerUnits@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_markerUnits: *mut nsAtom; + #[link_name = "?markerWidth@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_markerWidth: *mut nsAtom; + #[link_name = "?mask@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mask: *mut nsAtom; + #[link_name = "?maskContentUnits@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_maskContentUnits: *mut nsAtom; + #[link_name = "?mask_type@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mask_type: *mut nsAtom; + #[link_name = "?maskUnits@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_maskUnits: *mut nsAtom; + #[link_name = "?matrix@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_matrix: *mut nsAtom; + #[link_name = "?metadata@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_metadata: *mut nsAtom; + #[link_name = "?missingGlyph@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_missingGlyph: *mut nsAtom; + #[link_name = "?mm@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mm: *mut nsAtom; + #[link_name = "?mpath@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mpath: *mut nsAtom; + #[link_name = "?noStitch@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_noStitch: *mut nsAtom; + #[link_name = "?numOctaves@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_numOctaves: *mut nsAtom; + #[link_name = "?multiply@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_multiply: *mut nsAtom; + #[link_name = "?objectBoundingBox@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_objectBoundingBox: *mut nsAtom; + #[link_name = "?offset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_offset: *mut nsAtom; + #[link_name = "?onSVGLoad@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onSVGLoad: *mut nsAtom; + #[link_name = "?onSVGResize@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onSVGResize: *mut nsAtom; + #[link_name = "?onSVGScroll@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onSVGScroll: *mut nsAtom; + #[link_name = "?onSVGUnload@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onSVGUnload: *mut nsAtom; + #[link_name = "?onSVGZoom@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onSVGZoom: *mut nsAtom; + #[link_name = "?onzoom@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onzoom: *mut nsAtom; + #[link_name = "?opacity@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_opacity: *mut nsAtom; + #[link_name = "?_operator@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__operator: *mut nsAtom; + #[link_name = "?out@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_out: *mut nsAtom; + #[link_name = "?over@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_over: *mut nsAtom; + #[link_name = "?overridePreserveAspectRatio@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_overridePreserveAspectRatio: *mut nsAtom; + #[link_name = "?pad@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pad: *mut nsAtom; + #[link_name = "?path@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_path: *mut nsAtom; + #[link_name = "?pathLength@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pathLength: *mut nsAtom; + #[link_name = "?patternContentUnits@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_patternContentUnits: *mut nsAtom; + #[link_name = "?patternTransform@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_patternTransform: *mut nsAtom; + #[link_name = "?patternUnits@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_patternUnits: *mut nsAtom; + #[link_name = "?pc@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pc: *mut nsAtom; + #[link_name = "?pointer_events@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pointer_events: *mut nsAtom; + #[link_name = "?points@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_points: *mut nsAtom; + #[link_name = "?pointsAtX@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pointsAtX: *mut nsAtom; + #[link_name = "?pointsAtY@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pointsAtY: *mut nsAtom; + #[link_name = "?pointsAtZ@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pointsAtZ: *mut nsAtom; + #[link_name = "?polyline@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_polyline: *mut nsAtom; + #[link_name = "?preserveAlpha@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_preserveAlpha: *mut nsAtom; + #[link_name = "?preserveAspectRatio@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_preserveAspectRatio: *mut nsAtom; + #[link_name = "?primitiveUnits@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_primitiveUnits: *mut nsAtom; + #[link_name = "?pt@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pt: *mut nsAtom; + #[link_name = "?px@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_px: *mut nsAtom; + #[link_name = "?R@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_R: *mut nsAtom; + #[link_name = "?r@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_r: *mut nsAtom; + #[link_name = "?rad@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rad: *mut nsAtom; + #[link_name = "?radialGradient@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_radialGradient: *mut nsAtom; + #[link_name = "?radius@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_radius: *mut nsAtom; + #[link_name = "?reflect@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_reflect: *mut nsAtom; + #[link_name = "?refX@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_refX: *mut nsAtom; + #[link_name = "?refY@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_refY: *mut nsAtom; + #[link_name = "?requiredExtensions@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_requiredExtensions: *mut nsAtom; + #[link_name = "?requiredFeatures@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_requiredFeatures: *mut nsAtom; + #[link_name = "?rotate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rotate: *mut nsAtom; + #[link_name = "?rx@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rx: *mut nsAtom; + #[link_name = "?ry@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ry: *mut nsAtom; + #[link_name = "?saturate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_saturate: *mut nsAtom; + #[link_name = "?saturation@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_saturation: *mut nsAtom; + #[link_name = "?set@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_set: *mut nsAtom; + #[link_name = "?seed@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_seed: *mut nsAtom; + #[link_name = "?shape_rendering@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_shape_rendering: *mut nsAtom; + #[link_name = "?skewX@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_skewX: *mut nsAtom; + #[link_name = "?skewY@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_skewY: *mut nsAtom; + #[link_name = "?slope@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_slope: *mut nsAtom; + #[link_name = "?slot@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_slot: *mut nsAtom; + #[link_name = "?softLight@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_softLight: *mut nsAtom; + #[link_name = "?spacing@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_spacing: *mut nsAtom; + #[link_name = "?spacingAndGlyphs@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_spacingAndGlyphs: *mut nsAtom; + #[link_name = "?specularConstant@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_specularConstant: *mut nsAtom; + #[link_name = "?specularExponent@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_specularExponent: *mut nsAtom; + #[link_name = "?spreadMethod@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_spreadMethod: *mut nsAtom; + #[link_name = "?sRGB@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sRGB: *mut nsAtom; + #[link_name = "?startOffset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_startOffset: *mut nsAtom; + #[link_name = "?stdDeviation@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stdDeviation: *mut nsAtom; + #[link_name = "?stitch@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stitch: *mut nsAtom; + #[link_name = "?stitchTiles@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stitchTiles: *mut nsAtom; + #[link_name = "?stop_color@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stop_color: *mut nsAtom; + #[link_name = "?stop_opacity@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stop_opacity: *mut nsAtom; + #[link_name = "?stroke@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stroke: *mut nsAtom; + #[link_name = "?stroke_dasharray@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stroke_dasharray: *mut nsAtom; + #[link_name = "?stroke_dashoffset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stroke_dashoffset: *mut nsAtom; + #[link_name = "?stroke_linecap@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stroke_linecap: *mut nsAtom; + #[link_name = "?stroke_linejoin@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stroke_linejoin: *mut nsAtom; + #[link_name = "?stroke_miterlimit@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stroke_miterlimit: *mut nsAtom; + #[link_name = "?stroke_opacity@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stroke_opacity: *mut nsAtom; + #[link_name = "?stroke_width@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stroke_width: *mut nsAtom; + #[link_name = "?strokeWidth@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_strokeWidth: *mut nsAtom; + #[link_name = "?surfaceScale@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_surfaceScale: *mut nsAtom; + #[link_name = "?svg@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_svg: *mut nsAtom; + #[link_name = "?svgContextPaint@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_svgContextPaint: *mut nsAtom; + #[link_name = "?svgSwitch@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_svgSwitch: *mut nsAtom; + #[link_name = "?symbol@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_symbol: *mut nsAtom; + #[link_name = "?systemLanguage@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_systemLanguage: *mut nsAtom; + #[link_name = "?tableValues@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tableValues: *mut nsAtom; + #[link_name = "?targetX@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_targetX: *mut nsAtom; + #[link_name = "?targetY@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_targetY: *mut nsAtom; + #[link_name = "?text_anchor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_text_anchor: *mut nsAtom; + #[link_name = "?text_rendering@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_text_rendering: *mut nsAtom; + #[link_name = "?textLength@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_textLength: *mut nsAtom; + #[link_name = "?textPath@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_textPath: *mut nsAtom; + #[link_name = "?tref@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tref: *mut nsAtom; + #[link_name = "?tspan@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tspan: *mut nsAtom; + #[link_name = "?turbulence@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_turbulence: *mut nsAtom; + #[link_name = "?unicode_bidi@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_unicode_bidi: *mut nsAtom; + #[link_name = "?userSpaceOnUse@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_userSpaceOnUse: *mut nsAtom; + #[link_name = "?view@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_view: *mut nsAtom; + #[link_name = "?viewBox@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_viewBox: *mut nsAtom; + #[link_name = "?viewTarget@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_viewTarget: *mut nsAtom; + #[link_name = "?white_space@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_white_space: *mut nsAtom; + #[link_name = "?word_spacing@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_word_spacing: *mut nsAtom; + #[link_name = "?writing_mode@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_writing_mode: *mut nsAtom; + #[link_name = "?x@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x: *mut nsAtom; + #[link_name = "?x1@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x1: *mut nsAtom; + #[link_name = "?x2@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x2: *mut nsAtom; + #[link_name = "?xChannelSelector@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xChannelSelector: *mut nsAtom; + #[link_name = "?xor_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xor_: *mut nsAtom; + #[link_name = "?y@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_y: *mut nsAtom; + #[link_name = "?y1@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_y1: *mut nsAtom; + #[link_name = "?y2@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_y2: *mut nsAtom; + #[link_name = "?yChannelSelector@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_yChannelSelector: *mut nsAtom; + #[link_name = "?z@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_z: *mut nsAtom; + #[link_name = "?zoomAndPan@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_zoomAndPan: *mut nsAtom; + #[link_name = "?vector_effect@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_vector_effect: *mut nsAtom; + #[link_name = "?vertical_align@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_vertical_align: *mut nsAtom; + #[link_name = "?accumulate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_accumulate: *mut nsAtom; + #[link_name = "?additive@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_additive: *mut nsAtom; + #[link_name = "?attributeName@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_attributeName: *mut nsAtom; + #[link_name = "?attributeType@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_attributeType: *mut nsAtom; + #[link_name = "?auto_reverse@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_auto_reverse: *mut nsAtom; + #[link_name = "?begin@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_begin: *mut nsAtom; + #[link_name = "?beginEvent@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_beginEvent: *mut nsAtom; + #[link_name = "?by@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_by: *mut nsAtom; + #[link_name = "?calcMode@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_calcMode: *mut nsAtom; + #[link_name = "?css@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_css: *mut nsAtom; + #[link_name = "?dur@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_dur: *mut nsAtom; + #[link_name = "?keyPoints@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_keyPoints: *mut nsAtom; + #[link_name = "?keySplines@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_keySplines: *mut nsAtom; + #[link_name = "?keyTimes@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_keyTimes: *mut nsAtom; + #[link_name = "?mozAnimateMotionDummyAttr@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozAnimateMotionDummyAttr: *mut nsAtom; + #[link_name = "?onbegin@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onbegin: *mut nsAtom; + #[link_name = "?onbeginEvent@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onbeginEvent: *mut nsAtom; + #[link_name = "?onend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onend: *mut nsAtom; + #[link_name = "?onendEvent@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onendEvent: *mut nsAtom; + #[link_name = "?onrepeat@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onrepeat: *mut nsAtom; + #[link_name = "?onrepeatEvent@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onrepeatEvent: *mut nsAtom; + #[link_name = "?repeatCount@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_repeatCount: *mut nsAtom; + #[link_name = "?repeatDur@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_repeatDur: *mut nsAtom; + #[link_name = "?repeatEvent@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_repeatEvent: *mut nsAtom; + #[link_name = "?restart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_restart: *mut nsAtom; + #[link_name = "?to@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_to: *mut nsAtom; + #[link_name = "?XML@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_XML: *mut nsAtom; + #[link_name = "?abs_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_abs_: *mut nsAtom; + #[link_name = "?accent_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_accent_: *mut nsAtom; + #[link_name = "?accentunder_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_accentunder_: *mut nsAtom; + #[link_name = "?actiontype_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_actiontype_: *mut nsAtom; + #[link_name = "?alignmentscope_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_alignmentscope_: *mut nsAtom; + #[link_name = "?altimg_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_altimg_: *mut nsAtom; + #[link_name = "?altimg_height_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_altimg_height_: *mut nsAtom; + #[link_name = "?altimg_valign_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_altimg_valign_: *mut nsAtom; + #[link_name = "?altimg_width_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_altimg_width_: *mut nsAtom; + #[link_name = "?annotation_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_annotation_: *mut nsAtom; + #[link_name = "?annotation_xml_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_annotation_xml_: *mut nsAtom; + #[link_name = "?apply_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_apply_: *mut nsAtom; + #[link_name = "?approx_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_approx_: *mut nsAtom; + #[link_name = "?arccos_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_arccos_: *mut nsAtom; + #[link_name = "?arccosh_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_arccosh_: *mut nsAtom; + #[link_name = "?arccot_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_arccot_: *mut nsAtom; + #[link_name = "?arccoth_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_arccoth_: *mut nsAtom; + #[link_name = "?arccsc_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_arccsc_: *mut nsAtom; + #[link_name = "?arccsch_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_arccsch_: *mut nsAtom; + #[link_name = "?arcsec_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_arcsec_: *mut nsAtom; + #[link_name = "?arcsech_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_arcsech_: *mut nsAtom; + #[link_name = "?arcsin_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_arcsin_: *mut nsAtom; + #[link_name = "?arcsinh_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_arcsinh_: *mut nsAtom; + #[link_name = "?arctan_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_arctan_: *mut nsAtom; + #[link_name = "?arctanh_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_arctanh_: *mut nsAtom; + #[link_name = "?arg_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_arg_: *mut nsAtom; + #[link_name = "?bevelled_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_bevelled_: *mut nsAtom; + #[link_name = "?bind_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_bind_: *mut nsAtom; + #[link_name = "?bvar_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_bvar_: *mut nsAtom; + #[link_name = "?card_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_card_: *mut nsAtom; + #[link_name = "?cartesianproduct_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cartesianproduct_: *mut nsAtom; + #[link_name = "?cbytes_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cbytes_: *mut nsAtom; + #[link_name = "?cd_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cd_: *mut nsAtom; + #[link_name = "?cdgroup_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cdgroup_: *mut nsAtom; + #[link_name = "?cerror_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cerror_: *mut nsAtom; + #[link_name = "?charalign_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_charalign_: *mut nsAtom; + #[link_name = "?ci_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ci_: *mut nsAtom; + #[link_name = "?closure_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_closure_: *mut nsAtom; + #[link_name = "?cn_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cn_: *mut nsAtom; + #[link_name = "?codomain_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_codomain_: *mut nsAtom; + #[link_name = "?columnalign_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_columnalign_: *mut nsAtom; + #[link_name = "?columnalignment_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_columnalignment_: *mut nsAtom; + #[link_name = "?columnlines_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_columnlines_: *mut nsAtom; + #[link_name = "?columnspacing_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_columnspacing_: *mut nsAtom; + #[link_name = "?columnspan_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_columnspan_: *mut nsAtom; + #[link_name = "?columnwidth_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_columnwidth_: *mut nsAtom; + #[link_name = "?complexes_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_complexes_: *mut nsAtom; + #[link_name = "?compose_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_compose_: *mut nsAtom; + #[link_name = "?condition_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_condition_: *mut nsAtom; + #[link_name = "?conjugate_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_conjugate_: *mut nsAtom; + #[link_name = "?cos_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cos_: *mut nsAtom; + #[link_name = "?cosh_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cosh_: *mut nsAtom; + #[link_name = "?cot_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cot_: *mut nsAtom; + #[link_name = "?coth_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_coth_: *mut nsAtom; + #[link_name = "?crossout_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_crossout_: *mut nsAtom; + #[link_name = "?csc_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_csc_: *mut nsAtom; + #[link_name = "?csch_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_csch_: *mut nsAtom; + #[link_name = "?cs_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cs_: *mut nsAtom; + #[link_name = "?csymbol_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_csymbol_: *mut nsAtom; + #[link_name = "?curl_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_curl_: *mut nsAtom; + #[link_name = "?decimalpoint_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_decimalpoint_: *mut nsAtom; + #[link_name = "?definitionURL_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_definitionURL_: *mut nsAtom; + #[link_name = "?degree_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_degree_: *mut nsAtom; + #[link_name = "?denomalign_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_denomalign_: *mut nsAtom; + #[link_name = "?depth_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_depth_: *mut nsAtom; + #[link_name = "?determinant_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_determinant_: *mut nsAtom; + #[link_name = "?diff_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_diff_: *mut nsAtom; + #[link_name = "?displaystyle_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_displaystyle_: *mut nsAtom; + #[link_name = "?divergence_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_divergence_: *mut nsAtom; + #[link_name = "?divide_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_divide_: *mut nsAtom; + #[link_name = "?domain_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_domain_: *mut nsAtom; + #[link_name = "?domainofapplication_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_domainofapplication_: *mut nsAtom; + #[link_name = "?edge_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_edge_: *mut nsAtom; + #[link_name = "?el_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_el_: *mut nsAtom; + #[link_name = "?emptyset_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_emptyset_: *mut nsAtom; + #[link_name = "?eq_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_eq_: *mut nsAtom; + #[link_name = "?equalcolumns_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_equalcolumns_: *mut nsAtom; + #[link_name = "?equalrows_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_equalrows_: *mut nsAtom; + #[link_name = "?equivalent_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_equivalent_: *mut nsAtom; + #[link_name = "?eulergamma_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_eulergamma_: *mut nsAtom; + #[link_name = "?exists_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_exists_: *mut nsAtom; + #[link_name = "?exp_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_exp_: *mut nsAtom; + #[link_name = "?exponentiale_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_exponentiale_: *mut nsAtom; + #[link_name = "?factorial_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_factorial_: *mut nsAtom; + #[link_name = "?factorof_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_factorof_: *mut nsAtom; + #[link_name = "?fence_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fence_: *mut nsAtom; + #[link_name = "?fn_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fn_: *mut nsAtom; + #[link_name = "?fontfamily_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fontfamily_: *mut nsAtom; + #[link_name = "?fontsize_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fontsize_: *mut nsAtom; + #[link_name = "?fontstyle_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fontstyle_: *mut nsAtom; + #[link_name = "?fontweight_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fontweight_: *mut nsAtom; + #[link_name = "?forall_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_forall_: *mut nsAtom; + #[link_name = "?framespacing_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_framespacing_: *mut nsAtom; + #[link_name = "?gcd_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_gcd_: *mut nsAtom; + #[link_name = "?geq_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_geq_: *mut nsAtom; + #[link_name = "?groupalign_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_groupalign_: *mut nsAtom; + #[link_name = "?gt_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_gt_: *mut nsAtom; + #[link_name = "?ident_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ident_: *mut nsAtom; + #[link_name = "?imaginaryi_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_imaginaryi_: *mut nsAtom; + #[link_name = "?imaginary_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_imaginary_: *mut nsAtom; + #[link_name = "?implies_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_implies_: *mut nsAtom; + #[link_name = "?indentalignfirst_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_indentalignfirst_: *mut nsAtom; + #[link_name = "?indentalign_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_indentalign_: *mut nsAtom; + #[link_name = "?indentalignlast_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_indentalignlast_: *mut nsAtom; + #[link_name = "?indentshiftfirst_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_indentshiftfirst_: *mut nsAtom; + #[link_name = "?indentshift_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_indentshift_: *mut nsAtom; + #[link_name = "?indenttarget_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_indenttarget_: *mut nsAtom; + #[link_name = "?integers_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_integers_: *mut nsAtom; + #[link_name = "?intersect_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_intersect_: *mut nsAtom; + #[link_name = "?interval_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_interval_: *mut nsAtom; + #[link_name = "?int_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_int_: *mut nsAtom; + #[link_name = "?inverse_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_inverse_: *mut nsAtom; + #[link_name = "?lambda_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lambda_: *mut nsAtom; + #[link_name = "?laplacian_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_laplacian_: *mut nsAtom; + #[link_name = "?largeop_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_largeop_: *mut nsAtom; + #[link_name = "?lcm_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lcm_: *mut nsAtom; + #[link_name = "?leq_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_leq_: *mut nsAtom; + #[link_name = "?limit_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_limit_: *mut nsAtom; + #[link_name = "?linebreak_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_linebreak_: *mut nsAtom; + #[link_name = "?linebreakmultchar_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_linebreakmultchar_: *mut nsAtom; + #[link_name = "?linebreakstyle_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_linebreakstyle_: *mut nsAtom; + #[link_name = "?linethickness_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_linethickness_: *mut nsAtom; + #[link_name = "?list_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_list_: *mut nsAtom; + #[link_name = "?ln_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ln_: *mut nsAtom; + #[link_name = "?location_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_location_: *mut nsAtom; + #[link_name = "?logbase_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_logbase_: *mut nsAtom; + #[link_name = "?log_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_log_: *mut nsAtom; + #[link_name = "?longdivstyle_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_longdivstyle_: *mut nsAtom; + #[link_name = "?lowlimit_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lowlimit_: *mut nsAtom; + #[link_name = "?lquote_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lquote_: *mut nsAtom; + #[link_name = "?lspace_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lspace_: *mut nsAtom; + #[link_name = "?lt_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lt_: *mut nsAtom; + #[link_name = "?maction_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_maction_: *mut nsAtom; + #[link_name = "?maligngroup_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_maligngroup_: *mut nsAtom; + #[link_name = "?malignmark_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_malignmark_: *mut nsAtom; + #[link_name = "?mathbackground_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mathbackground_: *mut nsAtom; + #[link_name = "?mathcolor_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mathcolor_: *mut nsAtom; + #[link_name = "?mathsize_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mathsize_: *mut nsAtom; + #[link_name = "?mathvariant_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mathvariant_: *mut nsAtom; + #[link_name = "?matrixrow_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_matrixrow_: *mut nsAtom; + #[link_name = "?maxsize_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_maxsize_: *mut nsAtom; + #[link_name = "?mean_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mean_: *mut nsAtom; + #[link_name = "?median_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_median_: *mut nsAtom; + #[link_name = "?menclose_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_menclose_: *mut nsAtom; + #[link_name = "?merror_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_merror_: *mut nsAtom; + #[link_name = "?mfenced_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mfenced_: *mut nsAtom; + #[link_name = "?mfrac_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mfrac_: *mut nsAtom; + #[link_name = "?mglyph_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mglyph_: *mut nsAtom; + #[link_name = "?mi_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mi_: *mut nsAtom; + #[link_name = "?minlabelspacing_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_minlabelspacing_: *mut nsAtom; + #[link_name = "?minsize_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_minsize_: *mut nsAtom; + #[link_name = "?minus_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_minus_: *mut nsAtom; + #[link_name = "?mlabeledtr_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mlabeledtr_: *mut nsAtom; + #[link_name = "?mlongdiv_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mlongdiv_: *mut nsAtom; + #[link_name = "?mmultiscripts_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mmultiscripts_: *mut nsAtom; + #[link_name = "?mn_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mn_: *mut nsAtom; + #[link_name = "?momentabout_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_momentabout_: *mut nsAtom; + #[link_name = "?moment_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_moment_: *mut nsAtom; + #[link_name = "?mo_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mo_: *mut nsAtom; + #[link_name = "?movablelimits_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_movablelimits_: *mut nsAtom; + #[link_name = "?mover_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mover_: *mut nsAtom; + #[link_name = "?mpadded_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mpadded_: *mut nsAtom; + #[link_name = "?mphantom_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mphantom_: *mut nsAtom; + #[link_name = "?mprescripts_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mprescripts_: *mut nsAtom; + #[link_name = "?mroot_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mroot_: *mut nsAtom; + #[link_name = "?mrow_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mrow_: *mut nsAtom; + #[link_name = "?mscarries_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mscarries_: *mut nsAtom; + #[link_name = "?mscarry_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mscarry_: *mut nsAtom; + #[link_name = "?msgroup_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_msgroup_: *mut nsAtom; + #[link_name = "?msline_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_msline_: *mut nsAtom; + #[link_name = "?ms_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ms_: *mut nsAtom; + #[link_name = "?mspace_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mspace_: *mut nsAtom; + #[link_name = "?msqrt_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_msqrt_: *mut nsAtom; + #[link_name = "?msrow_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_msrow_: *mut nsAtom; + #[link_name = "?mstack_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mstack_: *mut nsAtom; + #[link_name = "?mstyle_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mstyle_: *mut nsAtom; + #[link_name = "?msub_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_msub_: *mut nsAtom; + #[link_name = "?msubsup_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_msubsup_: *mut nsAtom; + #[link_name = "?msup_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_msup_: *mut nsAtom; + #[link_name = "?mtable_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mtable_: *mut nsAtom; + #[link_name = "?mtd_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mtd_: *mut nsAtom; + #[link_name = "?mtext_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mtext_: *mut nsAtom; + #[link_name = "?mtr_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mtr_: *mut nsAtom; + #[link_name = "?munder_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_munder_: *mut nsAtom; + #[link_name = "?munderover_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_munderover_: *mut nsAtom; + #[link_name = "?naturalnumbers_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_naturalnumbers_: *mut nsAtom; + #[link_name = "?neq_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_neq_: *mut nsAtom; + #[link_name = "?notanumber_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_notanumber_: *mut nsAtom; + #[link_name = "?notation_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_notation_: *mut nsAtom; + #[link_name = "?note_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_note_: *mut nsAtom; + #[link_name = "?notin_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_notin_: *mut nsAtom; + #[link_name = "?notprsubset_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_notprsubset_: *mut nsAtom; + #[link_name = "?notsubset_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_notsubset_: *mut nsAtom; + #[link_name = "?numalign_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_numalign_: *mut nsAtom; + #[link_name = "?other_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_other_: *mut nsAtom; + #[link_name = "?outerproduct_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_outerproduct_: *mut nsAtom; + #[link_name = "?partialdiff_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_partialdiff_: *mut nsAtom; + #[link_name = "?piece_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_piece_: *mut nsAtom; + #[link_name = "?piecewise_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_piecewise_: *mut nsAtom; + #[link_name = "?pi_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pi_: *mut nsAtom; + #[link_name = "?plus_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_plus_: *mut nsAtom; + #[link_name = "?power_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_power_: *mut nsAtom; + #[link_name = "?primes_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_primes_: *mut nsAtom; + #[link_name = "?product_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_product_: *mut nsAtom; + #[link_name = "?prsubset_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_prsubset_: *mut nsAtom; + #[link_name = "?quotient_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_quotient_: *mut nsAtom; + #[link_name = "?rationals_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rationals_: *mut nsAtom; + #[link_name = "?real_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_real_: *mut nsAtom; + #[link_name = "?reals_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_reals_: *mut nsAtom; + #[link_name = "?reln_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_reln_: *mut nsAtom; + #[link_name = "?root_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_root_: *mut nsAtom; + #[link_name = "?rowalign_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rowalign_: *mut nsAtom; + #[link_name = "?rowlines_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rowlines_: *mut nsAtom; + #[link_name = "?rowspacing_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rowspacing_: *mut nsAtom; + #[link_name = "?rquote_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rquote_: *mut nsAtom; + #[link_name = "?rspace_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rspace_: *mut nsAtom; + #[link_name = "?scalarproduct_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scalarproduct_: *mut nsAtom; + #[link_name = "?schemaLocation_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_schemaLocation_: *mut nsAtom; + #[link_name = "?scriptlevel_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scriptlevel_: *mut nsAtom; + #[link_name = "?scriptminsize_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scriptminsize_: *mut nsAtom; + #[link_name = "?scriptsizemultiplier_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scriptsizemultiplier_: *mut nsAtom; + #[link_name = "?scriptsize_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scriptsize_: *mut nsAtom; + #[link_name = "?sdev_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sdev_: *mut nsAtom; + #[link_name = "?sech_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sech_: *mut nsAtom; + #[link_name = "?sec_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sec_: *mut nsAtom; + #[link_name = "?selection_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_selection_: *mut nsAtom; + #[link_name = "?selector_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_selector_: *mut nsAtom; + #[link_name = "?semantics_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_semantics_: *mut nsAtom; + #[link_name = "?separator_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_separator_: *mut nsAtom; + #[link_name = "?separators_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_separators_: *mut nsAtom; + #[link_name = "?sep_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sep_: *mut nsAtom; + #[link_name = "?setdiff_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_setdiff_: *mut nsAtom; + #[link_name = "?set_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_set_: *mut nsAtom; + #[link_name = "?share_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_share_: *mut nsAtom; + #[link_name = "?shift_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_shift_: *mut nsAtom; + #[link_name = "?side_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_side_: *mut nsAtom; + #[link_name = "?sinh_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sinh_: *mut nsAtom; + #[link_name = "?sin_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sin_: *mut nsAtom; + #[link_name = "?stackalign_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stackalign_: *mut nsAtom; + #[link_name = "?stretchy_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stretchy_: *mut nsAtom; + #[link_name = "?subscriptshift_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_subscriptshift_: *mut nsAtom; + #[link_name = "?subset_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_subset_: *mut nsAtom; + #[link_name = "?superscriptshift_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_superscriptshift_: *mut nsAtom; + #[link_name = "?symmetric_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_symmetric_: *mut nsAtom; + #[link_name = "?tanh_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tanh_: *mut nsAtom; + #[link_name = "?tan_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tan_: *mut nsAtom; + #[link_name = "?tendsto_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tendsto_: *mut nsAtom; + #[link_name = "?times_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_times_: *mut nsAtom; + #[link_name = "?transpose_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_transpose_: *mut nsAtom; + #[link_name = "?union_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_union_: *mut nsAtom; + #[link_name = "?uplimit_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_uplimit_: *mut nsAtom; + #[link_name = "?variance_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_variance_: *mut nsAtom; + #[link_name = "?vectorproduct_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_vectorproduct_: *mut nsAtom; + #[link_name = "?vector_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_vector_: *mut nsAtom; + #[link_name = "?voffset_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_voffset_: *mut nsAtom; + #[link_name = "?xref_@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xref_: *mut nsAtom; + #[link_name = "?math@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_math: *mut nsAtom; + #[link_name = "?avg@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_avg: *mut nsAtom; + #[link_name = "?booleanFromString@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_booleanFromString: *mut nsAtom; + #[link_name = "?countNonEmpty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_countNonEmpty: *mut nsAtom; + #[link_name = "?daysFromDate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_daysFromDate: *mut nsAtom; + #[link_name = "?init@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_init: *mut nsAtom; + #[link_name = "?instance@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_instance: *mut nsAtom; + #[link_name = "?months@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_months: *mut nsAtom; + #[link_name = "?now@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_now: *mut nsAtom; + #[link_name = "?seconds@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_seconds: *mut nsAtom; + #[link_name = "?secondsFromDateTime@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_secondsFromDateTime: *mut nsAtom; + #[link_name = "?onMozSwipeGestureMayStart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onMozSwipeGestureMayStart: *mut nsAtom; + #[link_name = "?onMozSwipeGestureStart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onMozSwipeGestureStart: *mut nsAtom; + #[link_name = "?onMozSwipeGestureUpdate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onMozSwipeGestureUpdate: *mut nsAtom; + #[link_name = "?onMozSwipeGestureEnd@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onMozSwipeGestureEnd: *mut nsAtom; + #[link_name = "?onMozSwipeGesture@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onMozSwipeGesture: *mut nsAtom; + #[link_name = "?onMozMagnifyGestureStart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onMozMagnifyGestureStart: *mut nsAtom; + #[link_name = "?onMozMagnifyGestureUpdate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onMozMagnifyGestureUpdate: *mut nsAtom; + #[link_name = "?onMozMagnifyGesture@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onMozMagnifyGesture: *mut nsAtom; + #[link_name = "?onMozRotateGestureStart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onMozRotateGestureStart: *mut nsAtom; + #[link_name = "?onMozRotateGestureUpdate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onMozRotateGestureUpdate: *mut nsAtom; + #[link_name = "?onMozRotateGesture@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onMozRotateGesture: *mut nsAtom; + #[link_name = "?onMozTapGesture@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onMozTapGesture: *mut nsAtom; + #[link_name = "?onMozPressTapGesture@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onMozPressTapGesture: *mut nsAtom; + #[link_name = "?onMozEdgeUIStarted@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onMozEdgeUIStarted: *mut nsAtom; + #[link_name = "?onMozEdgeUICanceled@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onMozEdgeUICanceled: *mut nsAtom; + #[link_name = "?onMozEdgeUICompleted@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onMozEdgeUICompleted: *mut nsAtom; + #[link_name = "?onpointerdown@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpointerdown: *mut nsAtom; + #[link_name = "?onpointermove@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpointermove: *mut nsAtom; + #[link_name = "?onpointerup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpointerup: *mut nsAtom; + #[link_name = "?onpointercancel@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpointercancel: *mut nsAtom; + #[link_name = "?onpointerover@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpointerover: *mut nsAtom; + #[link_name = "?onpointerout@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpointerout: *mut nsAtom; + #[link_name = "?onpointerenter@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpointerenter: *mut nsAtom; + #[link_name = "?onpointerleave@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpointerleave: *mut nsAtom; + #[link_name = "?ongotpointercapture@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ongotpointercapture: *mut nsAtom; + #[link_name = "?onlostpointercapture@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onlostpointercapture: *mut nsAtom; + #[link_name = "?ondevicemotion@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondevicemotion: *mut nsAtom; + #[link_name = "?ondeviceorientation@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondeviceorientation: *mut nsAtom; + #[link_name = "?onabsolutedeviceorientation@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onabsolutedeviceorientation: *mut nsAtom; + #[link_name = "?ondeviceproximity@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondeviceproximity: *mut nsAtom; + #[link_name = "?onmozorientationchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmozorientationchange: *mut nsAtom; + #[link_name = "?onuserproximity@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onuserproximity: *mut nsAtom; + #[link_name = "?ondevicelight@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondevicelight: *mut nsAtom; + #[link_name = "?ondevicechange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondevicechange: *mut nsAtom; + #[link_name = "?mozinputrangeignorepreventdefault@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozinputrangeignorepreventdefault: *mut nsAtom; + #[link_name = "?moz_extension@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_moz_extension: *mut nsAtom; + #[link_name = "?all_urlsPermission@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_all_urlsPermission: *mut nsAtom; + #[link_name = "?clipboardRead@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_clipboardRead: *mut nsAtom; + #[link_name = "?clipboardWrite@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_clipboardWrite: *mut nsAtom; + #[link_name = "?debugger@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_debugger: *mut nsAtom; + #[link_name = "?tabs@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tabs: *mut nsAtom; + #[link_name = "?webRequestBlocking@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_webRequestBlocking: *mut nsAtom; + #[link_name = "?http@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_http: *mut nsAtom; + #[link_name = "?https@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_https: *mut nsAtom; + #[link_name = "?proxy@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_proxy: *mut nsAtom; + #[link_name = "?cdataTagName@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cdataTagName: *mut nsAtom; + #[link_name = "?commentTagName@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_commentTagName: *mut nsAtom; + #[link_name = "?documentNodeName@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_documentNodeName: *mut nsAtom; + #[link_name = "?documentFragmentNodeName@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_documentFragmentNodeName: *mut nsAtom; + #[link_name = "?documentTypeNodeName@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_documentTypeNodeName: *mut nsAtom; + #[link_name = "?processingInstructionTagName@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_processingInstructionTagName: *mut nsAtom; + #[link_name = "?textTagName@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_textTagName: *mut nsAtom; + #[link_name = "?placeholderFrame@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_placeholderFrame: *mut nsAtom; + #[link_name = "?onloadend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onloadend: *mut nsAtom; + #[link_name = "?onloadstart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onloadstart: *mut nsAtom; + #[link_name = "?onprogress@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onprogress: *mut nsAtom; + #[link_name = "?onsuspend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onsuspend: *mut nsAtom; + #[link_name = "?onemptied@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onemptied: *mut nsAtom; + #[link_name = "?onstalled@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onstalled: *mut nsAtom; + #[link_name = "?onplay@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onplay: *mut nsAtom; + #[link_name = "?onpause@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onpause: *mut nsAtom; + #[link_name = "?onloadedmetadata@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onloadedmetadata: *mut nsAtom; + #[link_name = "?onloadeddata@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onloadeddata: *mut nsAtom; + #[link_name = "?onwaiting@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onwaiting: *mut nsAtom; + #[link_name = "?onplaying@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onplaying: *mut nsAtom; + #[link_name = "?oncanplay@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncanplay: *mut nsAtom; + #[link_name = "?oncanplaythrough@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncanplaythrough: *mut nsAtom; + #[link_name = "?onseeking@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onseeking: *mut nsAtom; + #[link_name = "?onseeked@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onseeked: *mut nsAtom; + #[link_name = "?ontimeout@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ontimeout: *mut nsAtom; + #[link_name = "?ontimeupdate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ontimeupdate: *mut nsAtom; + #[link_name = "?onended@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onended: *mut nsAtom; + #[link_name = "?onratechange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onratechange: *mut nsAtom; + #[link_name = "?ondurationchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondurationchange: *mut nsAtom; + #[link_name = "?onvolumechange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onvolumechange: *mut nsAtom; + #[link_name = "?onaddtrack@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onaddtrack: *mut nsAtom; + #[link_name = "?oncontrollerchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncontrollerchange: *mut nsAtom; + #[link_name = "?oncuechange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_oncuechange: *mut nsAtom; + #[link_name = "?onenter@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onenter: *mut nsAtom; + #[link_name = "?onexit@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onexit: *mut nsAtom; + #[link_name = "?onencrypted@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onencrypted: *mut nsAtom; + #[link_name = "?encrypted@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_encrypted: *mut nsAtom; + #[link_name = "?onwaitingforkey@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onwaitingforkey: *mut nsAtom; + #[link_name = "?onkeystatuseschange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onkeystatuseschange: *mut nsAtom; + #[link_name = "?onremovetrack@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onremovetrack: *mut nsAtom; + #[link_name = "?loadstart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_loadstart: *mut nsAtom; + #[link_name = "?suspend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_suspend: *mut nsAtom; + #[link_name = "?emptied@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_emptied: *mut nsAtom; + #[link_name = "?stalled@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stalled: *mut nsAtom; + #[link_name = "?play@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_play: *mut nsAtom; + #[link_name = "?pause@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pause: *mut nsAtom; + #[link_name = "?loadedmetadata@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_loadedmetadata: *mut nsAtom; + #[link_name = "?loadeddata@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_loadeddata: *mut nsAtom; + #[link_name = "?waiting@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_waiting: *mut nsAtom; + #[link_name = "?playing@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_playing: *mut nsAtom; + #[link_name = "?seeking@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_seeking: *mut nsAtom; + #[link_name = "?seeked@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_seeked: *mut nsAtom; + #[link_name = "?timeupdate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_timeupdate: *mut nsAtom; + #[link_name = "?ended@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ended: *mut nsAtom; + #[link_name = "?canplay@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_canplay: *mut nsAtom; + #[link_name = "?canplaythrough@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_canplaythrough: *mut nsAtom; + #[link_name = "?ratechange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ratechange: *mut nsAtom; + #[link_name = "?durationchange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_durationchange: *mut nsAtom; + #[link_name = "?volumechange@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_volumechange: *mut nsAtom; + #[link_name = "?ondataavailable@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ondataavailable: *mut nsAtom; + #[link_name = "?onwarning@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onwarning: *mut nsAtom; + #[link_name = "?onstart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onstart: *mut nsAtom; + #[link_name = "?onstop@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onstop: *mut nsAtom; + #[link_name = "?onphoto@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onphoto: *mut nsAtom; + #[link_name = "?onactivestatechanged@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onactivestatechanged: *mut nsAtom; + #[link_name = "?ongamepadbuttondown@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ongamepadbuttondown: *mut nsAtom; + #[link_name = "?ongamepadbuttonup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ongamepadbuttonup: *mut nsAtom; + #[link_name = "?ongamepadaxismove@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ongamepadaxismove: *mut nsAtom; + #[link_name = "?ongamepadconnected@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ongamepadconnected: *mut nsAtom; + #[link_name = "?ongamepaddisconnected@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ongamepaddisconnected: *mut nsAtom; + #[link_name = "?afterPseudoProperty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_afterPseudoProperty: *mut nsAtom; + #[link_name = "?animationsProperty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_animationsProperty: *mut nsAtom; + #[link_name = "?animationsOfBeforeProperty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_animationsOfBeforeProperty: *mut nsAtom; + #[link_name = "?animationsOfAfterProperty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_animationsOfAfterProperty: *mut nsAtom; + #[link_name = "?animationEffectsProperty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_animationEffectsProperty: *mut nsAtom; + #[link_name = "?animationEffectsForBeforeProperty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_animationEffectsForBeforeProperty: *mut nsAtom; + #[link_name = "?animationEffectsForAfterProperty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_animationEffectsForAfterProperty: *mut nsAtom; + #[link_name = "?beforePseudoProperty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_beforePseudoProperty: *mut nsAtom; + #[link_name = "?cssPseudoElementBeforeProperty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cssPseudoElementBeforeProperty: *mut nsAtom; + #[link_name = "?cssPseudoElementAfterProperty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cssPseudoElementAfterProperty: *mut nsAtom; + #[link_name = "?transitionsProperty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_transitionsProperty: *mut nsAtom; + #[link_name = "?transitionsOfBeforeProperty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_transitionsOfBeforeProperty: *mut nsAtom; + #[link_name = "?transitionsOfAfterProperty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_transitionsOfAfterProperty: *mut nsAtom; + #[link_name = "?genConInitializerProperty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_genConInitializerProperty: *mut nsAtom; + #[link_name = "?labelMouseDownPtProperty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_labelMouseDownPtProperty: *mut nsAtom; + #[link_name = "?lockedStyleStates@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lockedStyleStates: *mut nsAtom; + #[link_name = "?apzCallbackTransform@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_apzCallbackTransform: *mut nsAtom; + #[link_name = "?restylableAnonymousNode@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_restylableAnonymousNode: *mut nsAtom; + #[link_name = "?paintRequestTime@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_paintRequestTime: *mut nsAtom; + #[link_name = "?pseudoProperty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pseudoProperty: *mut nsAtom; + #[link_name = "?manualNACProperty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_manualNACProperty: *mut nsAtom; + #[link_name = "?Japanese@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_Japanese: *mut nsAtom; + #[link_name = "?Chinese@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_Chinese: *mut nsAtom; + #[link_name = "?Taiwanese@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_Taiwanese: *mut nsAtom; + #[link_name = "?HongKongChinese@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_HongKongChinese: *mut nsAtom; + #[link_name = "?Unicode@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_Unicode: *mut nsAtom; + #[link_name = "?ko@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ko: *mut nsAtom; + #[link_name = "?zh_cn@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_zh_cn: *mut nsAtom; + #[link_name = "?zh_hk@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_zh_hk: *mut nsAtom; + #[link_name = "?zh_tw@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_zh_tw: *mut nsAtom; + #[link_name = "?x_cyrillic@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x_cyrillic: *mut nsAtom; + #[link_name = "?he@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_he: *mut nsAtom; + #[link_name = "?ar@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ar: *mut nsAtom; + #[link_name = "?x_devanagari@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x_devanagari: *mut nsAtom; + #[link_name = "?x_tamil@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x_tamil: *mut nsAtom; + #[link_name = "?x_armn@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x_armn: *mut nsAtom; + #[link_name = "?x_beng@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x_beng: *mut nsAtom; + #[link_name = "?x_cans@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x_cans: *mut nsAtom; + #[link_name = "?x_ethi@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x_ethi: *mut nsAtom; + #[link_name = "?x_geor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x_geor: *mut nsAtom; + #[link_name = "?x_gujr@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x_gujr: *mut nsAtom; + #[link_name = "?x_guru@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x_guru: *mut nsAtom; + #[link_name = "?x_khmr@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x_khmr: *mut nsAtom; + #[link_name = "?x_knda@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x_knda: *mut nsAtom; + #[link_name = "?x_mlym@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x_mlym: *mut nsAtom; + #[link_name = "?x_orya@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x_orya: *mut nsAtom; + #[link_name = "?x_sinh@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x_sinh: *mut nsAtom; + #[link_name = "?x_telu@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x_telu: *mut nsAtom; + #[link_name = "?x_tibt@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x_tibt: *mut nsAtom; + #[link_name = "?az@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_az: *mut nsAtom; + #[link_name = "?ba@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ba: *mut nsAtom; + #[link_name = "?crh@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_crh: *mut nsAtom; + #[link_name = "?el@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_el: *mut nsAtom; + #[link_name = "?ga@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ga: *mut nsAtom; + #[link_name = "?nl@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nl: *mut nsAtom; + #[link_name = "?x_math@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_x_math: *mut nsAtom; + #[link_name = "?TypingTxnName@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_TypingTxnName: *mut nsAtom; + #[link_name = "?IMETxnName@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_IMETxnName: *mut nsAtom; + #[link_name = "?DeleteTxnName@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_DeleteTxnName: *mut nsAtom; + #[link_name = "?serif@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_serif: *mut nsAtom; + #[link_name = "?sans_serif@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_sans_serif: *mut nsAtom; + #[link_name = "?cursive@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cursive: *mut nsAtom; + #[link_name = "?fantasy@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fantasy: *mut nsAtom; + #[link_name = "?monospace@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_monospace: *mut nsAtom; + #[link_name = "?mozfixed@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mozfixed: *mut nsAtom; + #[link_name = "?Remote@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_Remote: *mut nsAtom; + #[link_name = "?RemoteId@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_RemoteId: *mut nsAtom; + #[link_name = "?RemoteType@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_RemoteType: *mut nsAtom; + #[link_name = "?DisplayPort@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_DisplayPort: *mut nsAtom; + #[link_name = "?DisplayPortMargins@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_DisplayPortMargins: *mut nsAtom; + #[link_name = "?DisplayPortBase@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_DisplayPortBase: *mut nsAtom; + #[link_name = "?AsyncScrollLayerCreationFailed@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_AsyncScrollLayerCreationFailed: *mut nsAtom; + #[link_name = "?forcemessagemanager@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_forcemessagemanager: *mut nsAtom; + #[link_name = "?isPreloadBrowser@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_isPreloadBrowser: *mut nsAtom; + #[link_name = "?color_picker_available@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_color_picker_available: *mut nsAtom; + #[link_name = "?scrollbar_start_backward@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scrollbar_start_backward: *mut nsAtom; + #[link_name = "?scrollbar_start_forward@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scrollbar_start_forward: *mut nsAtom; + #[link_name = "?scrollbar_end_backward@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scrollbar_end_backward: *mut nsAtom; + #[link_name = "?scrollbar_end_forward@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scrollbar_end_forward: *mut nsAtom; + #[link_name = "?scrollbar_thumb_proportional@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scrollbar_thumb_proportional: *mut nsAtom; + #[link_name = "?overlay_scrollbars@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_overlay_scrollbars: *mut nsAtom; + #[link_name = "?windows_accent_color_in_titlebar@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_windows_accent_color_in_titlebar: *mut nsAtom; + #[link_name = "?windows_default_theme@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_windows_default_theme: *mut nsAtom; + #[link_name = "?mac_graphite_theme@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mac_graphite_theme: *mut nsAtom; + #[link_name = "?mac_yosemite_theme@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mac_yosemite_theme: *mut nsAtom; + #[link_name = "?windows_compositor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_windows_compositor: *mut nsAtom; + #[link_name = "?windows_glass@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_windows_glass: *mut nsAtom; + #[link_name = "?touch_enabled@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_touch_enabled: *mut nsAtom; + #[link_name = "?menubar_drag@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_menubar_drag: *mut nsAtom; + #[link_name = "?swipe_animation_enabled@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_swipe_animation_enabled: *mut nsAtom; + #[link_name = "?physical_home_button@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_physical_home_button: *mut nsAtom; + #[link_name = "?windows_classic@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_windows_classic: *mut nsAtom; + #[link_name = "?windows_theme_aero@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_windows_theme_aero: *mut nsAtom; + #[link_name = "?windows_theme_aero_lite@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_windows_theme_aero_lite: *mut nsAtom; + #[link_name = "?windows_theme_luna_blue@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_windows_theme_luna_blue: *mut nsAtom; + #[link_name = "?windows_theme_luna_olive@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_windows_theme_luna_olive: *mut nsAtom; + #[link_name = "?windows_theme_luna_silver@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_windows_theme_luna_silver: *mut nsAtom; + #[link_name = "?windows_theme_royale@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_windows_theme_royale: *mut nsAtom; + #[link_name = "?windows_theme_zune@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_windows_theme_zune: *mut nsAtom; + #[link_name = "?windows_theme_generic@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_windows_theme_generic: *mut nsAtom; + #[link_name = "?_moz_color_picker_available@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_color_picker_available: *mut nsAtom; + #[link_name = "?_moz_scrollbar_start_backward@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_scrollbar_start_backward: *mut nsAtom; + #[link_name = "?_moz_scrollbar_start_forward@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_scrollbar_start_forward: *mut nsAtom; + #[link_name = "?_moz_scrollbar_end_backward@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_scrollbar_end_backward: *mut nsAtom; + #[link_name = "?_moz_scrollbar_end_forward@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_scrollbar_end_forward: *mut nsAtom; + #[link_name = "?_moz_scrollbar_thumb_proportional@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_scrollbar_thumb_proportional: *mut nsAtom; + #[link_name = "?_moz_overlay_scrollbars@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_overlay_scrollbars: *mut nsAtom; + #[link_name = "?_moz_windows_accent_color_in_titlebar@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_windows_accent_color_in_titlebar: *mut nsAtom; + #[link_name = "?_moz_windows_default_theme@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_windows_default_theme: *mut nsAtom; + #[link_name = "?_moz_mac_graphite_theme@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_mac_graphite_theme: *mut nsAtom; + #[link_name = "?_moz_mac_yosemite_theme@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_mac_yosemite_theme: *mut nsAtom; + #[link_name = "?_moz_windows_compositor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_windows_compositor: *mut nsAtom; + #[link_name = "?_moz_windows_classic@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_windows_classic: *mut nsAtom; + #[link_name = "?_moz_windows_glass@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_windows_glass: *mut nsAtom; + #[link_name = "?_moz_windows_theme@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_windows_theme: *mut nsAtom; + #[link_name = "?_moz_os_version@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_os_version: *mut nsAtom; + #[link_name = "?_moz_touch_enabled@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_touch_enabled: *mut nsAtom; + #[link_name = "?_moz_menubar_drag@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_menubar_drag: *mut nsAtom; + #[link_name = "?_moz_device_pixel_ratio@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_device_pixel_ratio: *mut nsAtom; + #[link_name = "?_moz_device_orientation@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_device_orientation: *mut nsAtom; + #[link_name = "?_moz_is_resource_document@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_is_resource_document: *mut nsAtom; + #[link_name = "?_moz_swipe_animation_enabled@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_swipe_animation_enabled: *mut nsAtom; + #[link_name = "?_moz_physical_home_button@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__moz_physical_home_button: *mut nsAtom; + #[link_name = "?Back@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_Back: *mut nsAtom; + #[link_name = "?Forward@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_Forward: *mut nsAtom; + #[link_name = "?Reload@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_Reload: *mut nsAtom; + #[link_name = "?Stop@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_Stop: *mut nsAtom; + #[link_name = "?Search@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_Search: *mut nsAtom; + #[link_name = "?Bookmarks@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_Bookmarks: *mut nsAtom; + #[link_name = "?Home@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_Home: *mut nsAtom; + #[link_name = "?Clear@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_Clear: *mut nsAtom; + #[link_name = "?VolumeUp@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_VolumeUp: *mut nsAtom; + #[link_name = "?VolumeDown@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_VolumeDown: *mut nsAtom; + #[link_name = "?NextTrack@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_NextTrack: *mut nsAtom; + #[link_name = "?PreviousTrack@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_PreviousTrack: *mut nsAtom; + #[link_name = "?MediaStop@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_MediaStop: *mut nsAtom; + #[link_name = "?PlayPause@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_PlayPause: *mut nsAtom; + #[link_name = "?Menu@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_Menu: *mut nsAtom; + #[link_name = "?New@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_New: *mut nsAtom; + #[link_name = "?Open@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_Open: *mut nsAtom; + #[link_name = "?Close@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_Close: *mut nsAtom; + #[link_name = "?Save@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_Save: *mut nsAtom; + #[link_name = "?Find@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_Find: *mut nsAtom; + #[link_name = "?Help@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_Help: *mut nsAtom; + #[link_name = "?Print@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_Print: *mut nsAtom; + #[link_name = "?SendMail@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_SendMail: *mut nsAtom; + #[link_name = "?ForwardMail@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ForwardMail: *mut nsAtom; + #[link_name = "?ReplyToMail@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ReplyToMail: *mut nsAtom; + #[link_name = "?mouseWheel@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mouseWheel: *mut nsAtom; + #[link_name = "?pixels@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pixels: *mut nsAtom; + #[link_name = "?lines@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lines: *mut nsAtom; + #[link_name = "?pages@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pages: *mut nsAtom; + #[link_name = "?scrollbars@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_scrollbars: *mut nsAtom; + #[link_name = "?other@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_other: *mut nsAtom; + #[link_name = "?apz@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_apz: *mut nsAtom; + #[link_name = "?restore@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_restore: *mut nsAtom; + #[link_name = "?alert@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_alert: *mut nsAtom; + #[link_name = "?alertdialog@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_alertdialog: *mut nsAtom; + #[link_name = "?application@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_application: *mut nsAtom; + #[link_name = "?aria_colcount@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_colcount: *mut nsAtom; + #[link_name = "?aria_colindex@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_colindex: *mut nsAtom; + #[link_name = "?aria_details@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_details: *mut nsAtom; + #[link_name = "?aria_errormessage@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_errormessage: *mut nsAtom; + #[link_name = "?aria_grabbed@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_grabbed: *mut nsAtom; + #[link_name = "?aria_label@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_label: *mut nsAtom; + #[link_name = "?aria_modal@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_modal: *mut nsAtom; + #[link_name = "?aria_orientation@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_orientation: *mut nsAtom; + #[link_name = "?aria_rowcount@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_rowcount: *mut nsAtom; + #[link_name = "?aria_rowindex@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_rowindex: *mut nsAtom; + #[link_name = "?aria_valuetext@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_valuetext: *mut nsAtom; + #[link_name = "?auto_generated@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_auto_generated: *mut nsAtom; + #[link_name = "?banner@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_banner: *mut nsAtom; + #[link_name = "?checkable@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_checkable: *mut nsAtom; + #[link_name = "?choices@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_choices: *mut nsAtom; + #[link_name = "?columnheader@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_columnheader: *mut nsAtom; + #[link_name = "?complementary@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_complementary: *mut nsAtom; + #[link_name = "?containerAtomic@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_containerAtomic: *mut nsAtom; + #[link_name = "?containerBusy@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_containerBusy: *mut nsAtom; + #[link_name = "?containerLive@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_containerLive: *mut nsAtom; + #[link_name = "?containerLiveRole@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_containerLiveRole: *mut nsAtom; + #[link_name = "?containerRelevant@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_containerRelevant: *mut nsAtom; + #[link_name = "?contentinfo@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_contentinfo: *mut nsAtom; + #[link_name = "?cycles@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_cycles: *mut nsAtom; + #[link_name = "?datatable@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_datatable: *mut nsAtom; + #[link_name = "?eventFromInput@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_eventFromInput: *mut nsAtom; + #[link_name = "?feed@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feed: *mut nsAtom; + #[link_name = "?grammar@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_grammar: *mut nsAtom; + #[link_name = "?gridcell@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_gridcell: *mut nsAtom; + #[link_name = "?heading@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_heading: *mut nsAtom; + #[link_name = "?hitregion@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_hitregion: *mut nsAtom; + #[link_name = "?inlinevalue@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_inlinevalue: *mut nsAtom; + #[link_name = "?invalid@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_invalid: *mut nsAtom; + #[link_name = "?item@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_item: *mut nsAtom; + #[link_name = "?itemset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_itemset: *mut nsAtom; + #[link_name = "?lineNumber@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lineNumber: *mut nsAtom; + #[link_name = "?linkedPanel@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_linkedPanel: *mut nsAtom; + #[link_name = "?live@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_live: *mut nsAtom; + #[link_name = "?menuitemcheckbox@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_menuitemcheckbox: *mut nsAtom; + #[link_name = "?menuitemradio@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_menuitemradio: *mut nsAtom; + #[link_name = "?mixed@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_mixed: *mut nsAtom; + #[link_name = "?multiline@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_multiline: *mut nsAtom; + #[link_name = "?navigation@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_navigation: *mut nsAtom; + #[link_name = "?polite@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_polite: *mut nsAtom; + #[link_name = "?posinset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_posinset: *mut nsAtom; + #[link_name = "?presentation@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_presentation: *mut nsAtom; + #[link_name = "?progressbar@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_progressbar: *mut nsAtom; + #[link_name = "?region@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_region: *mut nsAtom; + #[link_name = "?rowgroup@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rowgroup: *mut nsAtom; + #[link_name = "?rowheader@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rowheader: *mut nsAtom; + #[link_name = "?search@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_search: *mut nsAtom; + #[link_name = "?searchbox@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_searchbox: *mut nsAtom; + #[link_name = "?select1@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_select1: *mut nsAtom; + #[link_name = "?setsize@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_setsize: *mut nsAtom; + #[link_name = "?spelling@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_spelling: *mut nsAtom; + #[link_name = "?spinbutton@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_spinbutton: *mut nsAtom; + #[link_name = "?status@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_status: *mut nsAtom; + #[link_name = "?tableCellIndex@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tableCellIndex: *mut nsAtom; + #[link_name = "?tablist@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tablist: *mut nsAtom; + #[link_name = "?textIndent@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_textIndent: *mut nsAtom; + #[link_name = "?textInputType@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_textInputType: *mut nsAtom; + #[link_name = "?textLineThroughColor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_textLineThroughColor: *mut nsAtom; + #[link_name = "?textLineThroughStyle@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_textLineThroughStyle: *mut nsAtom; + #[link_name = "?textPosition@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_textPosition: *mut nsAtom; + #[link_name = "?textUnderlineColor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_textUnderlineColor: *mut nsAtom; + #[link_name = "?textUnderlineStyle@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_textUnderlineStyle: *mut nsAtom; + #[link_name = "?timer@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_timer: *mut nsAtom; + #[link_name = "?toolbarname@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_toolbarname: *mut nsAtom; + #[link_name = "?toolbarseparator@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_toolbarseparator: *mut nsAtom; + #[link_name = "?toolbarspacer@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_toolbarspacer: *mut nsAtom; + #[link_name = "?toolbarspring@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_toolbarspring: *mut nsAtom; + #[link_name = "?treegrid@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_treegrid: *mut nsAtom; + #[link_name = "?_undefined@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms__undefined: *mut nsAtom; + #[link_name = "?xmlroles@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xmlroles: *mut nsAtom; + #[link_name = "?close_fence@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_close_fence: *mut nsAtom; + #[link_name = "?denominator@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_denominator: *mut nsAtom; + #[link_name = "?numerator@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_numerator: *mut nsAtom; + #[link_name = "?open_fence@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_open_fence: *mut nsAtom; + #[link_name = "?overscript@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_overscript: *mut nsAtom; + #[link_name = "?presubscript@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_presubscript: *mut nsAtom; + #[link_name = "?presuperscript@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_presuperscript: *mut nsAtom; + #[link_name = "?root_index@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_root_index: *mut nsAtom; + #[link_name = "?subscript@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_subscript: *mut nsAtom; + #[link_name = "?superscript@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_superscript: *mut nsAtom; + #[link_name = "?underscript@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_underscript: *mut nsAtom; + #[link_name = "?onaudiostart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onaudiostart: *mut nsAtom; + #[link_name = "?onaudioend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onaudioend: *mut nsAtom; + #[link_name = "?onsoundstart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onsoundstart: *mut nsAtom; + #[link_name = "?onsoundend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onsoundend: *mut nsAtom; + #[link_name = "?onspeechstart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onspeechstart: *mut nsAtom; + #[link_name = "?onspeechend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onspeechend: *mut nsAtom; + #[link_name = "?onresult@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onresult: *mut nsAtom; + #[link_name = "?onnomatch@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onnomatch: *mut nsAtom; + #[link_name = "?onresume@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onresume: *mut nsAtom; + #[link_name = "?onmark@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmark: *mut nsAtom; + #[link_name = "?onboundary@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onboundary: *mut nsAtom; + #[link_name = "?usercontextid@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_usercontextid: *mut nsAtom; + #[link_name = "?nsuri_xmlns@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nsuri_xmlns: *mut nsAtom; + #[link_name = "?nsuri_xml@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nsuri_xml: *mut nsAtom; + #[link_name = "?nsuri_xhtml@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nsuri_xhtml: *mut nsAtom; + #[link_name = "?nsuri_xlink@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nsuri_xlink: *mut nsAtom; + #[link_name = "?nsuri_xslt@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nsuri_xslt: *mut nsAtom; + #[link_name = "?nsuri_xbl@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nsuri_xbl: *mut nsAtom; + #[link_name = "?nsuri_mathml@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nsuri_mathml: *mut nsAtom; + #[link_name = "?nsuri_rdf@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nsuri_rdf: *mut nsAtom; + #[link_name = "?nsuri_xul@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nsuri_xul: *mut nsAtom; + #[link_name = "?nsuri_svg@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_nsuri_svg: *mut nsAtom; + #[link_name = "?onsourceopen@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onsourceopen: *mut nsAtom; + #[link_name = "?onsourceended@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onsourceended: *mut nsAtom; + #[link_name = "?onsourceclosed@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onsourceclosed: *mut nsAtom; + #[link_name = "?onupdatestart@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onupdatestart: *mut nsAtom; + #[link_name = "?onupdate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onupdate: *mut nsAtom; + #[link_name = "?onupdateend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onupdateend: *mut nsAtom; + #[link_name = "?onaddsourcebuffer@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onaddsourcebuffer: *mut nsAtom; + #[link_name = "?onremovesourcebuffer@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onremovesourcebuffer: *mut nsAtom; + #[link_name = "?xlink@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xlink: *mut nsAtom; + #[link_name = "?xml_space@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xml_space: *mut nsAtom; + #[link_name = "?xml_lang@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xml_lang: *mut nsAtom; + #[link_name = "?xml_base@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xml_base: *mut nsAtom; + #[link_name = "?aria_grab@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_grab: *mut nsAtom; + #[link_name = "?aria_channel@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_channel: *mut nsAtom; + #[link_name = "?aria_secret@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_secret: *mut nsAtom; + #[link_name = "?aria_templateid@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_templateid: *mut nsAtom; + #[link_name = "?aria_datatype@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_aria_datatype: *mut nsAtom; + #[link_name = "?local@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_local: *mut nsAtom; + #[link_name = "?xchannelselector@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xchannelselector: *mut nsAtom; + #[link_name = "?ychannelselector@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_ychannelselector: *mut nsAtom; + #[link_name = "?enable_background@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_enable_background: *mut nsAtom; + #[link_name = "?calcmode@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_calcmode: *mut nsAtom; + #[link_name = "?specularexponent@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_specularexponent: *mut nsAtom; + #[link_name = "?specularconstant@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_specularconstant: *mut nsAtom; + #[link_name = "?gradienttransform@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_gradienttransform: *mut nsAtom; + #[link_name = "?gradientunits@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_gradientunits: *mut nsAtom; + #[link_name = "?rendering_intent@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_rendering_intent: *mut nsAtom; + #[link_name = "?stddeviation@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stddeviation: *mut nsAtom; + #[link_name = "?basefrequency@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_basefrequency: *mut nsAtom; + #[link_name = "?baseprofile@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_baseprofile: *mut nsAtom; + #[link_name = "?baseProfile@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_baseProfile: *mut nsAtom; + #[link_name = "?edgemode@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_edgemode: *mut nsAtom; + #[link_name = "?repeatcount@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_repeatcount: *mut nsAtom; + #[link_name = "?repeatdur@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_repeatdur: *mut nsAtom; + #[link_name = "?spreadmethod@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_spreadmethod: *mut nsAtom; + #[link_name = "?diffuseconstant@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_diffuseconstant: *mut nsAtom; + #[link_name = "?surfacescale@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_surfacescale: *mut nsAtom; + #[link_name = "?lengthadjust@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lengthadjust: *mut nsAtom; + #[link_name = "?origin@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_origin: *mut nsAtom; + #[link_name = "?targetx@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_targetx: *mut nsAtom; + #[link_name = "?targety@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_targety: *mut nsAtom; + #[link_name = "?pathlength@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pathlength: *mut nsAtom; + #[link_name = "?definitionurl@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_definitionurl: *mut nsAtom; + #[link_name = "?limitingconeangle@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_limitingconeangle: *mut nsAtom; + #[link_name = "?markerheight@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_markerheight: *mut nsAtom; + #[link_name = "?markerwidth@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_markerwidth: *mut nsAtom; + #[link_name = "?maskunits@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_maskunits: *mut nsAtom; + #[link_name = "?markerunits@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_markerunits: *mut nsAtom; + #[link_name = "?maskcontentunits@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_maskcontentunits: *mut nsAtom; + #[link_name = "?tablevalues@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_tablevalues: *mut nsAtom; + #[link_name = "?primitiveunits@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_primitiveunits: *mut nsAtom; + #[link_name = "?zoomandpan@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_zoomandpan: *mut nsAtom; + #[link_name = "?kernelmatrix@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_kernelmatrix: *mut nsAtom; + #[link_name = "?kerning@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_kerning: *mut nsAtom; + #[link_name = "?kernelunitlength@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_kernelunitlength: *mut nsAtom; + #[link_name = "?pointsatx@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pointsatx: *mut nsAtom; + #[link_name = "?pointsaty@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pointsaty: *mut nsAtom; + #[link_name = "?pointsatz@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_pointsatz: *mut nsAtom; + #[link_name = "?xlink_href@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xlink_href: *mut nsAtom; + #[link_name = "?xlink_title@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xlink_title: *mut nsAtom; + #[link_name = "?xlink_role@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xlink_role: *mut nsAtom; + #[link_name = "?xlink_arcrole@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xlink_arcrole: *mut nsAtom; + #[link_name = "?arcrole@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_arcrole: *mut nsAtom; + #[link_name = "?xmlns_xlink@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xmlns_xlink: *mut nsAtom; + #[link_name = "?xlink_type@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xlink_type: *mut nsAtom; + #[link_name = "?xlink_show@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xlink_show: *mut nsAtom; + #[link_name = "?xlink_actuate@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_xlink_actuate: *mut nsAtom; + #[link_name = "?color_rendering@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_color_rendering: *mut nsAtom; + #[link_name = "?numoctaves@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_numoctaves: *mut nsAtom; + #[link_name = "?onmousewheel@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_onmousewheel: *mut nsAtom; + #[link_name = "?clippathunits@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_clippathunits: *mut nsAtom; + #[link_name = "?glyph_orientation_vertical@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_glyph_orientation_vertical: *mut nsAtom; + #[link_name = "?glyph_orientation_horizontal@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_glyph_orientation_horizontal: *mut nsAtom; + #[link_name = "?glyphref@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_glyphref: *mut nsAtom; + #[link_name = "?keypoints@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_keypoints: *mut nsAtom; + #[link_name = "?attributename@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_attributename: *mut nsAtom; + #[link_name = "?attributetype@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_attributetype: *mut nsAtom; + #[link_name = "?startoffset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_startoffset: *mut nsAtom; + #[link_name = "?keysplines@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_keysplines: *mut nsAtom; + #[link_name = "?preservealpha@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_preservealpha: *mut nsAtom; + #[link_name = "?preserveaspectratio@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_preserveaspectratio: *mut nsAtom; + #[link_name = "?alttext@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_alttext: *mut nsAtom; + #[link_name = "?filterunits@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_filterunits: *mut nsAtom; + #[link_name = "?keytimes@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_keytimes: *mut nsAtom; + #[link_name = "?patterntransform@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_patterntransform: *mut nsAtom; + #[link_name = "?patternunits@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_patternunits: *mut nsAtom; + #[link_name = "?patterncontentunits@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_patterncontentunits: *mut nsAtom; + #[link_name = "?stitchtiles@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_stitchtiles: *mut nsAtom; + #[link_name = "?systemlanguage@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_systemlanguage: *mut nsAtom; + #[link_name = "?textlength@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_textlength: *mut nsAtom; + #[link_name = "?requiredfeatures@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_requiredfeatures: *mut nsAtom; + #[link_name = "?requiredextensions@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_requiredextensions: *mut nsAtom; + #[link_name = "?viewtarget@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_viewtarget: *mut nsAtom; + #[link_name = "?viewbox@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_viewbox: *mut nsAtom; + #[link_name = "?refx@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_refx: *mut nsAtom; + #[link_name = "?refy@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_refy: *mut nsAtom; + #[link_name = "?fefunca@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fefunca: *mut nsAtom; + #[link_name = "?fefuncb@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fefuncb: *mut nsAtom; + #[link_name = "?feblend@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feblend: *mut nsAtom; + #[link_name = "?feflood@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feflood: *mut nsAtom; + #[link_name = "?feturbulence@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feturbulence: *mut nsAtom; + #[link_name = "?femergenode@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_femergenode: *mut nsAtom; + #[link_name = "?feimage@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feimage: *mut nsAtom; + #[link_name = "?femerge@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_femerge: *mut nsAtom; + #[link_name = "?fetile@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fetile: *mut nsAtom; + #[link_name = "?fecomposite@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fecomposite: *mut nsAtom; + #[link_name = "?altglyphdef@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_altglyphdef: *mut nsAtom; + #[link_name = "?altGlyphDef@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_altGlyphDef: *mut nsAtom; + #[link_name = "?fefuncg@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fefuncg: *mut nsAtom; + #[link_name = "?fediffuselighting@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fediffuselighting: *mut nsAtom; + #[link_name = "?fespecularlighting@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fespecularlighting: *mut nsAtom; + #[link_name = "?altglyph@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_altglyph: *mut nsAtom; + #[link_name = "?altGlyph@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_altGlyph: *mut nsAtom; + #[link_name = "?clippath@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_clippath: *mut nsAtom; + #[link_name = "?textpath@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_textpath: *mut nsAtom; + #[link_name = "?altglyphitem@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_altglyphitem: *mut nsAtom; + #[link_name = "?altGlyphItem@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_altGlyphItem: *mut nsAtom; + #[link_name = "?animatetransform@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_animatetransform: *mut nsAtom; + #[link_name = "?animatemotion@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_animatemotion: *mut nsAtom; + #[link_name = "?fedisplacementmap@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fedisplacementmap: *mut nsAtom; + #[link_name = "?animatecolor@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_animatecolor: *mut nsAtom; + #[link_name = "?fefuncr@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fefuncr: *mut nsAtom; + #[link_name = "?fecomponenttransfer@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fecomponenttransfer: *mut nsAtom; + #[link_name = "?fegaussianblur@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fegaussianblur: *mut nsAtom; + #[link_name = "?foreignobject@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_foreignobject: *mut nsAtom; + #[link_name = "?feoffset@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feoffset: *mut nsAtom; + #[link_name = "?fespotlight@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fespotlight: *mut nsAtom; + #[link_name = "?fepointlight@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fepointlight: *mut nsAtom; + #[link_name = "?fedistantlight@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fedistantlight: *mut nsAtom; + #[link_name = "?lineargradient@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_lineargradient: *mut nsAtom; + #[link_name = "?radialgradient@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_radialgradient: *mut nsAtom; + #[link_name = "?fedropshadow@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fedropshadow: *mut nsAtom; + #[link_name = "?fecolormatrix@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_fecolormatrix: *mut nsAtom; + #[link_name = "?feconvolvematrix@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_feconvolvematrix: *mut nsAtom; + #[link_name = "?femorphology@nsGkAtoms@@2PEAVnsAtom@@EA"] + pub static nsGkAtoms_femorphology: *mut nsAtom; #[link_name = "?after@nsCSSPseudoElements@@2PEAVnsICSSPseudoElement@@EA"] pub static nsCSSPseudoElements_after: *mut nsICSSPseudoElement; #[link_name = "?before@nsCSSPseudoElements@@2PEAVnsICSSPseudoElement@@EA"] @@ -10358,5006 +10358,5006 @@ cfg_if! { } } else { extern { - #[link_name = "\x01?_empty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__empty: *mut nsIAtom; - #[link_name = "\x01?moz@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_moz: *mut nsIAtom; - #[link_name = "\x01?mozframetype@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozframetype: *mut nsIAtom; - #[link_name = "\x01?_moz_abspos@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_abspos: *mut nsIAtom; - #[link_name = "\x01?_moz_activated@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_activated: *mut nsIAtom; - #[link_name = "\x01?_moz_anonclass@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_anonclass: *mut nsIAtom; - #[link_name = "\x01?_moz_resizing@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_resizing: *mut nsIAtom; - #[link_name = "\x01?mozallowfullscreen@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozallowfullscreen: *mut nsIAtom; - #[link_name = "\x01?moztype@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_moztype: *mut nsIAtom; - #[link_name = "\x01?mozdirty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozdirty: *mut nsIAtom; - #[link_name = "\x01?mozdisallowselectionprint@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozdisallowselectionprint: *mut nsIAtom; - #[link_name = "\x01?mozdonotsend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozdonotsend: *mut nsIAtom; - #[link_name = "\x01?mozeditorbogusnode@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozeditorbogusnode: *mut nsIAtom; - #[link_name = "\x01?mozgeneratedcontentbefore@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozgeneratedcontentbefore: *mut nsIAtom; - #[link_name = "\x01?mozgeneratedcontentafter@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozgeneratedcontentafter: *mut nsIAtom; - #[link_name = "\x01?mozgeneratedcontentimage@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozgeneratedcontentimage: *mut nsIAtom; - #[link_name = "\x01?mozquote@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozquote: *mut nsIAtom; - #[link_name = "\x01?mozsignature@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozsignature: *mut nsIAtom; - #[link_name = "\x01?_moz_is_glyph@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_is_glyph: *mut nsIAtom; - #[link_name = "\x01?_moz_original_size@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_original_size: *mut nsIAtom; - #[link_name = "\x01?_moz_target@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_target: *mut nsIAtom; - #[link_name = "\x01?menuactive@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_menuactive: *mut nsIAtom; - #[link_name = "\x01?_poundDefault@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__poundDefault: *mut nsIAtom; - #[link_name = "\x01?_asterisk@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__asterisk: *mut nsIAtom; - #[link_name = "\x01?a@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_a: *mut nsIAtom; - #[link_name = "\x01?abbr@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_abbr: *mut nsIAtom; - #[link_name = "\x01?abort@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_abort: *mut nsIAtom; - #[link_name = "\x01?above@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_above: *mut nsIAtom; - #[link_name = "\x01?acceltext@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_acceltext: *mut nsIAtom; - #[link_name = "\x01?accept@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_accept: *mut nsIAtom; - #[link_name = "\x01?acceptcharset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_acceptcharset: *mut nsIAtom; - #[link_name = "\x01?accesskey@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_accesskey: *mut nsIAtom; - #[link_name = "\x01?acronym@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_acronym: *mut nsIAtom; - #[link_name = "\x01?action@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_action: *mut nsIAtom; - #[link_name = "\x01?active@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_active: *mut nsIAtom; - #[link_name = "\x01?activetitlebarcolor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_activetitlebarcolor: *mut nsIAtom; - #[link_name = "\x01?activateontab@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_activateontab: *mut nsIAtom; - #[link_name = "\x01?actuate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_actuate: *mut nsIAtom; - #[link_name = "\x01?address@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_address: *mut nsIAtom; - #[link_name = "\x01?after@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_after: *mut nsIAtom; - #[link_name = "\x01?after_end@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_after_end: *mut nsIAtom; - #[link_name = "\x01?after_start@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_after_start: *mut nsIAtom; - #[link_name = "\x01?align@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_align: *mut nsIAtom; - #[link_name = "\x01?alink@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_alink: *mut nsIAtom; - #[link_name = "\x01?all@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_all: *mut nsIAtom; - #[link_name = "\x01?allowdirs@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_allowdirs: *mut nsIAtom; - #[link_name = "\x01?allowevents@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_allowevents: *mut nsIAtom; - #[link_name = "\x01?allownegativeassertions@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_allownegativeassertions: *mut nsIAtom; - #[link_name = "\x01?allowforms@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_allowforms: *mut nsIAtom; - #[link_name = "\x01?allowfullscreen@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_allowfullscreen: *mut nsIAtom; - #[link_name = "\x01?allowmodals@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_allowmodals: *mut nsIAtom; - #[link_name = "\x01?alloworientationlock@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_alloworientationlock: *mut nsIAtom; - #[link_name = "\x01?allowpaymentrequest@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_allowpaymentrequest: *mut nsIAtom; - #[link_name = "\x01?allowpointerlock@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_allowpointerlock: *mut nsIAtom; - #[link_name = "\x01?allowpopupstoescapesandbox@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_allowpopupstoescapesandbox: *mut nsIAtom; - #[link_name = "\x01?allowpopups@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_allowpopups: *mut nsIAtom; - #[link_name = "\x01?allowpresentation@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_allowpresentation: *mut nsIAtom; - #[link_name = "\x01?allowsameorigin@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_allowsameorigin: *mut nsIAtom; - #[link_name = "\x01?allowscripts@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_allowscripts: *mut nsIAtom; - #[link_name = "\x01?allowtopnavigation@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_allowtopnavigation: *mut nsIAtom; - #[link_name = "\x01?allowuntrusted@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_allowuntrusted: *mut nsIAtom; - #[link_name = "\x01?alt@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_alt: *mut nsIAtom; - #[link_name = "\x01?alternate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_alternate: *mut nsIAtom; - #[link_name = "\x01?always@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_always: *mut nsIAtom; - #[link_name = "\x01?ancestor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ancestor: *mut nsIAtom; - #[link_name = "\x01?ancestorOrSelf@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ancestorOrSelf: *mut nsIAtom; - #[link_name = "\x01?anchor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_anchor: *mut nsIAtom; - #[link_name = "\x01?_and@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__and: *mut nsIAtom; - #[link_name = "\x01?animations@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_animations: *mut nsIAtom; - #[link_name = "\x01?anonid@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_anonid: *mut nsIAtom; - #[link_name = "\x01?anonlocation@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_anonlocation: *mut nsIAtom; - #[link_name = "\x01?any@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_any: *mut nsIAtom; - #[link_name = "\x01?applet@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_applet: *mut nsIAtom; - #[link_name = "\x01?applyImports@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_applyImports: *mut nsIAtom; - #[link_name = "\x01?applyTemplates@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_applyTemplates: *mut nsIAtom; - #[link_name = "\x01?archive@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_archive: *mut nsIAtom; - #[link_name = "\x01?area@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_area: *mut nsIAtom; - #[link_name = "\x01?aria_activedescendant@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_activedescendant: *mut nsIAtom; - #[link_name = "\x01?aria_atomic@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_atomic: *mut nsIAtom; - #[link_name = "\x01?aria_autocomplete@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_autocomplete: *mut nsIAtom; - #[link_name = "\x01?aria_busy@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_busy: *mut nsIAtom; - #[link_name = "\x01?aria_checked@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_checked: *mut nsIAtom; - #[link_name = "\x01?aria_controls@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_controls: *mut nsIAtom; - #[link_name = "\x01?aria_current@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_current: *mut nsIAtom; - #[link_name = "\x01?aria_describedby@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_describedby: *mut nsIAtom; - #[link_name = "\x01?aria_disabled@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_disabled: *mut nsIAtom; - #[link_name = "\x01?aria_dropeffect@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_dropeffect: *mut nsIAtom; - #[link_name = "\x01?aria_expanded@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_expanded: *mut nsIAtom; - #[link_name = "\x01?aria_flowto@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_flowto: *mut nsIAtom; - #[link_name = "\x01?aria_haspopup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_haspopup: *mut nsIAtom; - #[link_name = "\x01?aria_hidden@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_hidden: *mut nsIAtom; - #[link_name = "\x01?aria_invalid@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_invalid: *mut nsIAtom; - #[link_name = "\x01?aria_labelledby@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_labelledby: *mut nsIAtom; - #[link_name = "\x01?aria_level@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_level: *mut nsIAtom; - #[link_name = "\x01?aria_live@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_live: *mut nsIAtom; - #[link_name = "\x01?aria_multiline@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_multiline: *mut nsIAtom; - #[link_name = "\x01?aria_multiselectable@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_multiselectable: *mut nsIAtom; - #[link_name = "\x01?aria_owns@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_owns: *mut nsIAtom; - #[link_name = "\x01?aria_posinset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_posinset: *mut nsIAtom; - #[link_name = "\x01?aria_pressed@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_pressed: *mut nsIAtom; - #[link_name = "\x01?aria_readonly@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_readonly: *mut nsIAtom; - #[link_name = "\x01?aria_relevant@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_relevant: *mut nsIAtom; - #[link_name = "\x01?aria_required@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_required: *mut nsIAtom; - #[link_name = "\x01?aria_selected@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_selected: *mut nsIAtom; - #[link_name = "\x01?aria_setsize@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_setsize: *mut nsIAtom; - #[link_name = "\x01?aria_sort@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_sort: *mut nsIAtom; - #[link_name = "\x01?aria_valuemax@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_valuemax: *mut nsIAtom; - #[link_name = "\x01?aria_valuemin@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_valuemin: *mut nsIAtom; - #[link_name = "\x01?aria_valuenow@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_valuenow: *mut nsIAtom; - #[link_name = "\x01?arrow@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_arrow: *mut nsIAtom; - #[link_name = "\x01?article@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_article: *mut nsIAtom; - #[link_name = "\x01?as@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_as: *mut nsIAtom; - #[link_name = "\x01?ascending@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ascending: *mut nsIAtom; - #[link_name = "\x01?aside@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aside: *mut nsIAtom; - #[link_name = "\x01?aspectRatio@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aspectRatio: *mut nsIAtom; - #[link_name = "\x01?assign@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_assign: *mut nsIAtom; - #[link_name = "\x01?async@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_async: *mut nsIAtom; - #[link_name = "\x01?attribute@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_attribute: *mut nsIAtom; - #[link_name = "\x01?attributes@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_attributes: *mut nsIAtom; - #[link_name = "\x01?attributeSet@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_attributeSet: *mut nsIAtom; - #[link_name = "\x01?aural@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aural: *mut nsIAtom; - #[link_name = "\x01?_auto@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__auto: *mut nsIAtom; - #[link_name = "\x01?autocheck@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_autocheck: *mut nsIAtom; - #[link_name = "\x01?autocomplete@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_autocomplete: *mut nsIAtom; - #[link_name = "\x01?autofocus@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_autofocus: *mut nsIAtom; - #[link_name = "\x01?autoplay@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_autoplay: *mut nsIAtom; - #[link_name = "\x01?autorepeatbutton@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_autorepeatbutton: *mut nsIAtom; - #[link_name = "\x01?axis@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_axis: *mut nsIAtom; - #[link_name = "\x01?b@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_b: *mut nsIAtom; - #[link_name = "\x01?background@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_background: *mut nsIAtom; - #[link_name = "\x01?base@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_base: *mut nsIAtom; - #[link_name = "\x01?basefont@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_basefont: *mut nsIAtom; - #[link_name = "\x01?baseline@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_baseline: *mut nsIAtom; - #[link_name = "\x01?bdi@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_bdi: *mut nsIAtom; - #[link_name = "\x01?bdo@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_bdo: *mut nsIAtom; - #[link_name = "\x01?before@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_before: *mut nsIAtom; - #[link_name = "\x01?before_end@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_before_end: *mut nsIAtom; - #[link_name = "\x01?before_start@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_before_start: *mut nsIAtom; - #[link_name = "\x01?below@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_below: *mut nsIAtom; - #[link_name = "\x01?bgcolor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_bgcolor: *mut nsIAtom; - #[link_name = "\x01?bgsound@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_bgsound: *mut nsIAtom; - #[link_name = "\x01?big@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_big: *mut nsIAtom; - #[link_name = "\x01?binding@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_binding: *mut nsIAtom; - #[link_name = "\x01?bindings@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_bindings: *mut nsIAtom; - #[link_name = "\x01?bindToUntrustedContent@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_bindToUntrustedContent: *mut nsIAtom; - #[link_name = "\x01?blankrow@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_blankrow: *mut nsIAtom; - #[link_name = "\x01?block@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_block: *mut nsIAtom; - #[link_name = "\x01?blockquote@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_blockquote: *mut nsIAtom; - #[link_name = "\x01?blur@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_blur: *mut nsIAtom; - #[link_name = "\x01?body@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_body: *mut nsIAtom; - #[link_name = "\x01?boolean@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_boolean: *mut nsIAtom; - #[link_name = "\x01?border@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_border: *mut nsIAtom; - #[link_name = "\x01?bordercolor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_bordercolor: *mut nsIAtom; - #[link_name = "\x01?both@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_both: *mut nsIAtom; - #[link_name = "\x01?bottom@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_bottom: *mut nsIAtom; - #[link_name = "\x01?bottomend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_bottomend: *mut nsIAtom; - #[link_name = "\x01?bottomstart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_bottomstart: *mut nsIAtom; - #[link_name = "\x01?bottomleft@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_bottomleft: *mut nsIAtom; - #[link_name = "\x01?bottommargin@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_bottommargin: *mut nsIAtom; - #[link_name = "\x01?bottompadding@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_bottompadding: *mut nsIAtom; - #[link_name = "\x01?bottomright@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_bottomright: *mut nsIAtom; - #[link_name = "\x01?box@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_box: *mut nsIAtom; - #[link_name = "\x01?br@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_br: *mut nsIAtom; - #[link_name = "\x01?braille@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_braille: *mut nsIAtom; - #[link_name = "\x01?broadcast@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_broadcast: *mut nsIAtom; - #[link_name = "\x01?broadcaster@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_broadcaster: *mut nsIAtom; - #[link_name = "\x01?broadcasterset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_broadcasterset: *mut nsIAtom; - #[link_name = "\x01?browser@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_browser: *mut nsIAtom; - #[link_name = "\x01?mozbrowser@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozbrowser: *mut nsIAtom; - #[link_name = "\x01?bulletinboard@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_bulletinboard: *mut nsIAtom; - #[link_name = "\x01?button@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_button: *mut nsIAtom; - #[link_name = "\x01?brighttitlebarforeground@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_brighttitlebarforeground: *mut nsIAtom; - #[link_name = "\x01?callTemplate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_callTemplate: *mut nsIAtom; - #[link_name = "\x01?cancel@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cancel: *mut nsIAtom; - #[link_name = "\x01?canvas@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_canvas: *mut nsIAtom; - #[link_name = "\x01?caption@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_caption: *mut nsIAtom; - #[link_name = "\x01?capture@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_capture: *mut nsIAtom; - #[link_name = "\x01?caseOrder@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_caseOrder: *mut nsIAtom; - #[link_name = "\x01?cdataSectionElements@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cdataSectionElements: *mut nsIAtom; - #[link_name = "\x01?ceiling@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ceiling: *mut nsIAtom; - #[link_name = "\x01?cell@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cell: *mut nsIAtom; - #[link_name = "\x01?cellpadding@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cellpadding: *mut nsIAtom; - #[link_name = "\x01?cellspacing@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cellspacing: *mut nsIAtom; - #[link_name = "\x01?center@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_center: *mut nsIAtom; - #[link_name = "\x01?ch@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ch: *mut nsIAtom; - #[link_name = "\x01?change@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_change: *mut nsIAtom; - #[link_name = "\x01?_char@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__char: *mut nsIAtom; - #[link_name = "\x01?characterData@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_characterData: *mut nsIAtom; - #[link_name = "\x01?charcode@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_charcode: *mut nsIAtom; - #[link_name = "\x01?charoff@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_charoff: *mut nsIAtom; - #[link_name = "\x01?charset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_charset: *mut nsIAtom; - #[link_name = "\x01?checkbox@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_checkbox: *mut nsIAtom; - #[link_name = "\x01?checked@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_checked: *mut nsIAtom; - #[link_name = "\x01?child@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_child: *mut nsIAtom; - #[link_name = "\x01?children@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_children: *mut nsIAtom; - #[link_name = "\x01?childList@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_childList: *mut nsIAtom; - #[link_name = "\x01?choose@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_choose: *mut nsIAtom; - #[link_name = "\x01?chromemargin@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_chromemargin: *mut nsIAtom; - #[link_name = "\x01?chromeOnlyContent@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_chromeOnlyContent: *mut nsIAtom; - #[link_name = "\x01?exposeToUntrustedContent@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_exposeToUntrustedContent: *mut nsIAtom; - #[link_name = "\x01?circ@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_circ: *mut nsIAtom; - #[link_name = "\x01?circle@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_circle: *mut nsIAtom; - #[link_name = "\x01?cite@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cite: *mut nsIAtom; - #[link_name = "\x01?cjkDecimal@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cjkDecimal: *mut nsIAtom; - #[link_name = "\x01?_class@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__class: *mut nsIAtom; - #[link_name = "\x01?classid@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_classid: *mut nsIAtom; - #[link_name = "\x01?clear@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_clear: *mut nsIAtom; - #[link_name = "\x01?click@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_click: *mut nsIAtom; - #[link_name = "\x01?clickcount@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_clickcount: *mut nsIAtom; - #[link_name = "\x01?clickthrough@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_clickthrough: *mut nsIAtom; - #[link_name = "\x01?movetoclick@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_movetoclick: *mut nsIAtom; - #[link_name = "\x01?clip@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_clip: *mut nsIAtom; - #[link_name = "\x01?close@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_close: *mut nsIAtom; - #[link_name = "\x01?closed@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_closed: *mut nsIAtom; - #[link_name = "\x01?closemenu@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_closemenu: *mut nsIAtom; - #[link_name = "\x01?coalesceduplicatearcs@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_coalesceduplicatearcs: *mut nsIAtom; - #[link_name = "\x01?code@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_code: *mut nsIAtom; - #[link_name = "\x01?codebase@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_codebase: *mut nsIAtom; - #[link_name = "\x01?codetype@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_codetype: *mut nsIAtom; - #[link_name = "\x01?col@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_col: *mut nsIAtom; - #[link_name = "\x01?colgroup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_colgroup: *mut nsIAtom; - #[link_name = "\x01?collapse@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_collapse: *mut nsIAtom; - #[link_name = "\x01?collapsed@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_collapsed: *mut nsIAtom; - #[link_name = "\x01?color@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_color: *mut nsIAtom; - #[link_name = "\x01?colorIndex@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_colorIndex: *mut nsIAtom; - #[link_name = "\x01?cols@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cols: *mut nsIAtom; - #[link_name = "\x01?colspan@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_colspan: *mut nsIAtom; - #[link_name = "\x01?column@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_column: *mut nsIAtom; - #[link_name = "\x01?columns@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_columns: *mut nsIAtom; - #[link_name = "\x01?combobox@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_combobox: *mut nsIAtom; - #[link_name = "\x01?command@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_command: *mut nsIAtom; - #[link_name = "\x01?commands@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_commands: *mut nsIAtom; - #[link_name = "\x01?commandset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_commandset: *mut nsIAtom; - #[link_name = "\x01?commandupdate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_commandupdate: *mut nsIAtom; - #[link_name = "\x01?commandupdater@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_commandupdater: *mut nsIAtom; - #[link_name = "\x01?comment@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_comment: *mut nsIAtom; - #[link_name = "\x01?compact@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_compact: *mut nsIAtom; - #[link_name = "\x01?concat@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_concat: *mut nsIAtom; - #[link_name = "\x01?conditions@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_conditions: *mut nsIAtom; - #[link_name = "\x01?constructor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_constructor: *mut nsIAtom; - #[link_name = "\x01?consumeoutsideclicks@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_consumeoutsideclicks: *mut nsIAtom; - #[link_name = "\x01?container@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_container: *mut nsIAtom; - #[link_name = "\x01?containment@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_containment: *mut nsIAtom; - #[link_name = "\x01?contains@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_contains: *mut nsIAtom; - #[link_name = "\x01?content@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_content: *mut nsIAtom; - #[link_name = "\x01?contenteditable@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_contenteditable: *mut nsIAtom; - #[link_name = "\x01?headerContentDisposition@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_headerContentDisposition: *mut nsIAtom; - #[link_name = "\x01?headerContentLanguage@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_headerContentLanguage: *mut nsIAtom; - #[link_name = "\x01?contentLocation@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_contentLocation: *mut nsIAtom; - #[link_name = "\x01?headerContentScriptType@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_headerContentScriptType: *mut nsIAtom; - #[link_name = "\x01?headerContentStyleType@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_headerContentStyleType: *mut nsIAtom; - #[link_name = "\x01?headerContentType@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_headerContentType: *mut nsIAtom; - #[link_name = "\x01?consumeanchor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_consumeanchor: *mut nsIAtom; - #[link_name = "\x01?context@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_context: *mut nsIAtom; - #[link_name = "\x01?contextmenu@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_contextmenu: *mut nsIAtom; - #[link_name = "\x01?control@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_control: *mut nsIAtom; - #[link_name = "\x01?controls@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_controls: *mut nsIAtom; - #[link_name = "\x01?coords@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_coords: *mut nsIAtom; - #[link_name = "\x01?copy@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_copy: *mut nsIAtom; - #[link_name = "\x01?copyOf@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_copyOf: *mut nsIAtom; - #[link_name = "\x01?count@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_count: *mut nsIAtom; - #[link_name = "\x01?crop@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_crop: *mut nsIAtom; - #[link_name = "\x01?crossorigin@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_crossorigin: *mut nsIAtom; - #[link_name = "\x01?curpos@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_curpos: *mut nsIAtom; - #[link_name = "\x01?current@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_current: *mut nsIAtom; - #[link_name = "\x01?cutoutregion@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cutoutregion: *mut nsIAtom; - #[link_name = "\x01?cycler@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cycler: *mut nsIAtom; - #[link_name = "\x01?data@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_data: *mut nsIAtom; - #[link_name = "\x01?datalist@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_datalist: *mut nsIAtom; - #[link_name = "\x01?dataType@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dataType: *mut nsIAtom; - #[link_name = "\x01?dateTime@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dateTime: *mut nsIAtom; - #[link_name = "\x01?datasources@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_datasources: *mut nsIAtom; - #[link_name = "\x01?datetime@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_datetime: *mut nsIAtom; - #[link_name = "\x01?datetimebox@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_datetimebox: *mut nsIAtom; - #[link_name = "\x01?dblclick@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dblclick: *mut nsIAtom; - #[link_name = "\x01?dd@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dd: *mut nsIAtom; - #[link_name = "\x01?debug@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_debug: *mut nsIAtom; - #[link_name = "\x01?decimal@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_decimal: *mut nsIAtom; - #[link_name = "\x01?decimalFormat@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_decimalFormat: *mut nsIAtom; - #[link_name = "\x01?decimalSeparator@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_decimalSeparator: *mut nsIAtom; - #[link_name = "\x01?deck@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_deck: *mut nsIAtom; - #[link_name = "\x01?declare@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_declare: *mut nsIAtom; - #[link_name = "\x01?decoderDoctor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_decoderDoctor: *mut nsIAtom; - #[link_name = "\x01?decrement@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_decrement: *mut nsIAtom; - #[link_name = "\x01?_default@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__default: *mut nsIAtom; - #[link_name = "\x01?headerDefaultStyle@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_headerDefaultStyle: *mut nsIAtom; - #[link_name = "\x01?defaultAction@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_defaultAction: *mut nsIAtom; - #[link_name = "\x01?defaultchecked@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_defaultchecked: *mut nsIAtom; - #[link_name = "\x01?defaultLabel@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_defaultLabel: *mut nsIAtom; - #[link_name = "\x01?defaultselected@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_defaultselected: *mut nsIAtom; - #[link_name = "\x01?defaultvalue@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_defaultvalue: *mut nsIAtom; - #[link_name = "\x01?defaultplaybackrate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_defaultplaybackrate: *mut nsIAtom; - #[link_name = "\x01?defer@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_defer: *mut nsIAtom; - #[link_name = "\x01?del@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_del: *mut nsIAtom; - #[link_name = "\x01?descendant@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_descendant: *mut nsIAtom; - #[link_name = "\x01?descendantOrSelf@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_descendantOrSelf: *mut nsIAtom; - #[link_name = "\x01?descending@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_descending: *mut nsIAtom; - #[link_name = "\x01?description@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_description: *mut nsIAtom; - #[link_name = "\x01?destructor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_destructor: *mut nsIAtom; - #[link_name = "\x01?details@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_details: *mut nsIAtom; - #[link_name = "\x01?deviceAspectRatio@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_deviceAspectRatio: *mut nsIAtom; - #[link_name = "\x01?deviceHeight@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_deviceHeight: *mut nsIAtom; - #[link_name = "\x01?devicePixelRatio@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_devicePixelRatio: *mut nsIAtom; - #[link_name = "\x01?deviceWidth@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_deviceWidth: *mut nsIAtom; - #[link_name = "\x01?dfn@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dfn: *mut nsIAtom; - #[link_name = "\x01?dialog@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dialog: *mut nsIAtom; - #[link_name = "\x01?difference@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_difference: *mut nsIAtom; - #[link_name = "\x01?digit@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_digit: *mut nsIAtom; - #[link_name = "\x01?dir@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dir: *mut nsIAtom; - #[link_name = "\x01?dirAutoSetBy@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dirAutoSetBy: *mut nsIAtom; - #[link_name = "\x01?directionality@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_directionality: *mut nsIAtom; - #[link_name = "\x01?directory@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_directory: *mut nsIAtom; - #[link_name = "\x01?disableOutputEscaping@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_disableOutputEscaping: *mut nsIAtom; - #[link_name = "\x01?disabled@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_disabled: *mut nsIAtom; - #[link_name = "\x01?disableglobalhistory@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_disableglobalhistory: *mut nsIAtom; - #[link_name = "\x01?disablehistory@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_disablehistory: *mut nsIAtom; - #[link_name = "\x01?disablefullscreen@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_disablefullscreen: *mut nsIAtom; - #[link_name = "\x01?disclosure_closed@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_disclosure_closed: *mut nsIAtom; - #[link_name = "\x01?disclosure_open@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_disclosure_open: *mut nsIAtom; - #[link_name = "\x01?display@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_display: *mut nsIAtom; - #[link_name = "\x01?displayMode@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_displayMode: *mut nsIAtom; - #[link_name = "\x01?distinct@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_distinct: *mut nsIAtom; - #[link_name = "\x01?div@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_div: *mut nsIAtom; - #[link_name = "\x01?dl@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dl: *mut nsIAtom; - #[link_name = "\x01?docAbstract@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docAbstract: *mut nsIAtom; - #[link_name = "\x01?docAcknowledgments@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docAcknowledgments: *mut nsIAtom; - #[link_name = "\x01?docAfterword@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docAfterword: *mut nsIAtom; - #[link_name = "\x01?docAppendix@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docAppendix: *mut nsIAtom; - #[link_name = "\x01?docBacklink@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docBacklink: *mut nsIAtom; - #[link_name = "\x01?docBiblioentry@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docBiblioentry: *mut nsIAtom; - #[link_name = "\x01?docBibliography@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docBibliography: *mut nsIAtom; - #[link_name = "\x01?docBiblioref@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docBiblioref: *mut nsIAtom; - #[link_name = "\x01?docChapter@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docChapter: *mut nsIAtom; - #[link_name = "\x01?docColophon@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docColophon: *mut nsIAtom; - #[link_name = "\x01?docConclusion@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docConclusion: *mut nsIAtom; - #[link_name = "\x01?docCover@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docCover: *mut nsIAtom; - #[link_name = "\x01?docCredit@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docCredit: *mut nsIAtom; - #[link_name = "\x01?docCredits@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docCredits: *mut nsIAtom; - #[link_name = "\x01?docDedication@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docDedication: *mut nsIAtom; - #[link_name = "\x01?docEndnote@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docEndnote: *mut nsIAtom; - #[link_name = "\x01?docEndnotes@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docEndnotes: *mut nsIAtom; - #[link_name = "\x01?docEpigraph@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docEpigraph: *mut nsIAtom; - #[link_name = "\x01?docEpilogue@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docEpilogue: *mut nsIAtom; - #[link_name = "\x01?docErrata@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docErrata: *mut nsIAtom; - #[link_name = "\x01?docExample@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docExample: *mut nsIAtom; - #[link_name = "\x01?docFootnote@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docFootnote: *mut nsIAtom; - #[link_name = "\x01?docForeword@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docForeword: *mut nsIAtom; - #[link_name = "\x01?docGlossary@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docGlossary: *mut nsIAtom; - #[link_name = "\x01?docGlossref@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docGlossref: *mut nsIAtom; - #[link_name = "\x01?docIndex@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docIndex: *mut nsIAtom; - #[link_name = "\x01?docIntroduction@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docIntroduction: *mut nsIAtom; - #[link_name = "\x01?docNoteref@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docNoteref: *mut nsIAtom; - #[link_name = "\x01?docNotice@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docNotice: *mut nsIAtom; - #[link_name = "\x01?docPagebreak@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docPagebreak: *mut nsIAtom; - #[link_name = "\x01?docPagelist@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docPagelist: *mut nsIAtom; - #[link_name = "\x01?docPart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docPart: *mut nsIAtom; - #[link_name = "\x01?docPreface@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docPreface: *mut nsIAtom; - #[link_name = "\x01?docPrologue@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docPrologue: *mut nsIAtom; - #[link_name = "\x01?docPullquote@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docPullquote: *mut nsIAtom; - #[link_name = "\x01?docQna@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docQna: *mut nsIAtom; - #[link_name = "\x01?docSubtitle@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docSubtitle: *mut nsIAtom; - #[link_name = "\x01?docTip@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docTip: *mut nsIAtom; - #[link_name = "\x01?docToc@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_docToc: *mut nsIAtom; - #[link_name = "\x01?doctypePublic@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_doctypePublic: *mut nsIAtom; - #[link_name = "\x01?doctypeSystem@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_doctypeSystem: *mut nsIAtom; - #[link_name = "\x01?document@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_document: *mut nsIAtom; - #[link_name = "\x01?download@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_download: *mut nsIAtom; - #[link_name = "\x01?DOMAttrModified@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_DOMAttrModified: *mut nsIAtom; - #[link_name = "\x01?DOMCharacterDataModified@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_DOMCharacterDataModified: *mut nsIAtom; - #[link_name = "\x01?DOMNodeInserted@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_DOMNodeInserted: *mut nsIAtom; - #[link_name = "\x01?DOMNodeInsertedIntoDocument@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_DOMNodeInsertedIntoDocument: *mut nsIAtom; - #[link_name = "\x01?DOMNodeRemoved@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_DOMNodeRemoved: *mut nsIAtom; - #[link_name = "\x01?DOMNodeRemovedFromDocument@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_DOMNodeRemovedFromDocument: *mut nsIAtom; - #[link_name = "\x01?DOMSubtreeModified@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_DOMSubtreeModified: *mut nsIAtom; - #[link_name = "\x01?double_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_double_: *mut nsIAtom; - #[link_name = "\x01?drag@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_drag: *mut nsIAtom; - #[link_name = "\x01?dragend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dragend: *mut nsIAtom; - #[link_name = "\x01?dragenter@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dragenter: *mut nsIAtom; - #[link_name = "\x01?dragevent@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dragevent: *mut nsIAtom; - #[link_name = "\x01?dragexit@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dragexit: *mut nsIAtom; - #[link_name = "\x01?draggable@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_draggable: *mut nsIAtom; - #[link_name = "\x01?dragging@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dragging: *mut nsIAtom; - #[link_name = "\x01?dragleave@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dragleave: *mut nsIAtom; - #[link_name = "\x01?dragover@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dragover: *mut nsIAtom; - #[link_name = "\x01?dragSession@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dragSession: *mut nsIAtom; - #[link_name = "\x01?dragstart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dragstart: *mut nsIAtom; - #[link_name = "\x01?drawintitlebar@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_drawintitlebar: *mut nsIAtom; - #[link_name = "\x01?drawtitle@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_drawtitle: *mut nsIAtom; - #[link_name = "\x01?drop@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_drop: *mut nsIAtom; - #[link_name = "\x01?dropAfter@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dropAfter: *mut nsIAtom; - #[link_name = "\x01?dropBefore@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dropBefore: *mut nsIAtom; - #[link_name = "\x01?dropOn@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dropOn: *mut nsIAtom; - #[link_name = "\x01?dropMarker@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dropMarker: *mut nsIAtom; - #[link_name = "\x01?dt@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dt: *mut nsIAtom; - #[link_name = "\x01?editable@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_editable: *mut nsIAtom; - #[link_name = "\x01?editing@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_editing: *mut nsIAtom; - #[link_name = "\x01?editor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_editor: *mut nsIAtom; - #[link_name = "\x01?editorDisplayList@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_editorDisplayList: *mut nsIAtom; - #[link_name = "\x01?element@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_element: *mut nsIAtom; - #[link_name = "\x01?elementAvailable@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_elementAvailable: *mut nsIAtom; - #[link_name = "\x01?elements@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_elements: *mut nsIAtom; - #[link_name = "\x01?em@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_em: *mut nsIAtom; - #[link_name = "\x01?embed@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_embed: *mut nsIAtom; - #[link_name = "\x01?embossed@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_embossed: *mut nsIAtom; - #[link_name = "\x01?empty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_empty: *mut nsIAtom; - #[link_name = "\x01?encoding@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_encoding: *mut nsIAtom; - #[link_name = "\x01?enctype@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_enctype: *mut nsIAtom; - #[link_name = "\x01?end@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_end: *mut nsIAtom; - #[link_name = "\x01?endEvent@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_endEvent: *mut nsIAtom; - #[link_name = "\x01?end_after@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_end_after: *mut nsIAtom; - #[link_name = "\x01?end_before@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_end_before: *mut nsIAtom; - #[link_name = "\x01?equalsize@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_equalsize: *mut nsIAtom; - #[link_name = "\x01?error@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_error: *mut nsIAtom; - #[link_name = "\x01?ethiopic_numeric@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ethiopic_numeric: *mut nsIAtom; - #[link_name = "\x01?even@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_even: *mut nsIAtom; - #[link_name = "\x01?event@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_event: *mut nsIAtom; - #[link_name = "\x01?events@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_events: *mut nsIAtom; - #[link_name = "\x01?excludeResultPrefixes@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_excludeResultPrefixes: *mut nsIAtom; - #[link_name = "\x01?excludes@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_excludes: *mut nsIAtom; - #[link_name = "\x01?expr@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_expr: *mut nsIAtom; - #[link_name = "\x01?extends@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_extends: *mut nsIAtom; - #[link_name = "\x01?extensionElementPrefixes@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_extensionElementPrefixes: *mut nsIAtom; - #[link_name = "\x01?face@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_face: *mut nsIAtom; - #[link_name = "\x01?fallback@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fallback: *mut nsIAtom; - #[link_name = "\x01?_false@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__false: *mut nsIAtom; - #[link_name = "\x01?farthest@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_farthest: *mut nsIAtom; - #[link_name = "\x01?field@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_field: *mut nsIAtom; - #[link_name = "\x01?fieldset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fieldset: *mut nsIAtom; - #[link_name = "\x01?file@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_file: *mut nsIAtom; - #[link_name = "\x01?figcaption@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_figcaption: *mut nsIAtom; - #[link_name = "\x01?figure@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_figure: *mut nsIAtom; - #[link_name = "\x01?fixed@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fixed: *mut nsIAtom; - #[link_name = "\x01?flags@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_flags: *mut nsIAtom; - #[link_name = "\x01?flex@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_flex: *mut nsIAtom; - #[link_name = "\x01?flexgroup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_flexgroup: *mut nsIAtom; - #[link_name = "\x01?flip@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_flip: *mut nsIAtom; - #[link_name = "\x01?floating@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_floating: *mut nsIAtom; - #[link_name = "\x01?floor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_floor: *mut nsIAtom; - #[link_name = "\x01?flowlength@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_flowlength: *mut nsIAtom; - #[link_name = "\x01?focus@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_focus: *mut nsIAtom; - #[link_name = "\x01?focused@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_focused: *mut nsIAtom; - #[link_name = "\x01?followanchor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_followanchor: *mut nsIAtom; - #[link_name = "\x01?following@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_following: *mut nsIAtom; - #[link_name = "\x01?followingSibling@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_followingSibling: *mut nsIAtom; - #[link_name = "\x01?font@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_font: *mut nsIAtom; - #[link_name = "\x01?fontWeight@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fontWeight: *mut nsIAtom; - #[link_name = "\x01?fontpicker@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fontpicker: *mut nsIAtom; - #[link_name = "\x01?footer@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_footer: *mut nsIAtom; - #[link_name = "\x01?_for@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__for: *mut nsIAtom; - #[link_name = "\x01?forEach@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_forEach: *mut nsIAtom; - #[link_name = "\x01?forceOwnRefreshDriver@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_forceOwnRefreshDriver: *mut nsIAtom; - #[link_name = "\x01?form@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_form: *mut nsIAtom; - #[link_name = "\x01?formaction@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_formaction: *mut nsIAtom; - #[link_name = "\x01?format@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_format: *mut nsIAtom; - #[link_name = "\x01?formatNumber@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_formatNumber: *mut nsIAtom; - #[link_name = "\x01?formenctype@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_formenctype: *mut nsIAtom; - #[link_name = "\x01?formmethod@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_formmethod: *mut nsIAtom; - #[link_name = "\x01?formnovalidate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_formnovalidate: *mut nsIAtom; - #[link_name = "\x01?formtarget@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_formtarget: *mut nsIAtom; - #[link_name = "\x01?frame@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_frame: *mut nsIAtom; - #[link_name = "\x01?frameborder@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_frameborder: *mut nsIAtom; - #[link_name = "\x01?frameset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_frameset: *mut nsIAtom; - #[link_name = "\x01?from@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_from: *mut nsIAtom; - #[link_name = "\x01?fullscreenchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fullscreenchange: *mut nsIAtom; - #[link_name = "\x01?fullscreenerror@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fullscreenerror: *mut nsIAtom; - #[link_name = "\x01?functionAvailable@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_functionAvailable: *mut nsIAtom; - #[link_name = "\x01?freshProcess@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_freshProcess: *mut nsIAtom; - #[link_name = "\x01?generateId@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_generateId: *mut nsIAtom; - #[link_name = "\x01?getter@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_getter: *mut nsIAtom; - #[link_name = "\x01?glyphchar@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_glyphchar: *mut nsIAtom; - #[link_name = "\x01?glyphid@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_glyphid: *mut nsIAtom; - #[link_name = "\x01?grid@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_grid: *mut nsIAtom; - #[link_name = "\x01?grippy@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_grippy: *mut nsIAtom; - #[link_name = "\x01?group@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_group: *mut nsIAtom; - #[link_name = "\x01?groupingSeparator@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_groupingSeparator: *mut nsIAtom; - #[link_name = "\x01?groupingSize@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_groupingSize: *mut nsIAtom; - #[link_name = "\x01?grow@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_grow: *mut nsIAtom; - #[link_name = "\x01?gutter@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_gutter: *mut nsIAtom; - #[link_name = "\x01?h1@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_h1: *mut nsIAtom; - #[link_name = "\x01?h2@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_h2: *mut nsIAtom; - #[link_name = "\x01?h3@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_h3: *mut nsIAtom; - #[link_name = "\x01?h4@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_h4: *mut nsIAtom; - #[link_name = "\x01?h5@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_h5: *mut nsIAtom; - #[link_name = "\x01?h6@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_h6: *mut nsIAtom; - #[link_name = "\x01?handheld@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_handheld: *mut nsIAtom; - #[link_name = "\x01?handheldFriendly@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_handheldFriendly: *mut nsIAtom; - #[link_name = "\x01?handler@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_handler: *mut nsIAtom; - #[link_name = "\x01?handlers@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_handlers: *mut nsIAtom; - #[link_name = "\x01?HARD@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_HARD: *mut nsIAtom; - #[link_name = "\x01?haspopup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_haspopup: *mut nsIAtom; - #[link_name = "\x01?hasSameNode@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_hasSameNode: *mut nsIAtom; - #[link_name = "\x01?hbox@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_hbox: *mut nsIAtom; - #[link_name = "\x01?head@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_head: *mut nsIAtom; - #[link_name = "\x01?header@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_header: *mut nsIAtom; - #[link_name = "\x01?headers@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_headers: *mut nsIAtom; - #[link_name = "\x01?hebrew@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_hebrew: *mut nsIAtom; - #[link_name = "\x01?height@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_height: *mut nsIAtom; - #[link_name = "\x01?hgroup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_hgroup: *mut nsIAtom; - #[link_name = "\x01?hidden@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_hidden: *mut nsIAtom; - #[link_name = "\x01?hidechrome@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_hidechrome: *mut nsIAtom; - #[link_name = "\x01?hidecolumnpicker@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_hidecolumnpicker: *mut nsIAtom; - #[link_name = "\x01?high@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_high: *mut nsIAtom; - #[link_name = "\x01?highest@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_highest: *mut nsIAtom; - #[link_name = "\x01?horizontal@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_horizontal: *mut nsIAtom; - #[link_name = "\x01?hover@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_hover: *mut nsIAtom; - #[link_name = "\x01?hr@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_hr: *mut nsIAtom; - #[link_name = "\x01?href@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_href: *mut nsIAtom; - #[link_name = "\x01?hreflang@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_hreflang: *mut nsIAtom; - #[link_name = "\x01?hspace@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_hspace: *mut nsIAtom; - #[link_name = "\x01?html@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_html: *mut nsIAtom; - #[link_name = "\x01?httpEquiv@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_httpEquiv: *mut nsIAtom; - #[link_name = "\x01?i@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_i: *mut nsIAtom; - #[link_name = "\x01?icon@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_icon: *mut nsIAtom; - #[link_name = "\x01?id@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_id: *mut nsIAtom; - #[link_name = "\x01?_if@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__if: *mut nsIAtom; - #[link_name = "\x01?iframe@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_iframe: *mut nsIAtom; - #[link_name = "\x01?ignorecase@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ignorecase: *mut nsIAtom; - #[link_name = "\x01?ignorekeys@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ignorekeys: *mut nsIAtom; - #[link_name = "\x01?ignoreuserfocus@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ignoreuserfocus: *mut nsIAtom; - #[link_name = "\x01?ilayer@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ilayer: *mut nsIAtom; - #[link_name = "\x01?image@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_image: *mut nsIAtom; - #[link_name = "\x01?imageClickedPoint@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_imageClickedPoint: *mut nsIAtom; - #[link_name = "\x01?img@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_img: *mut nsIAtom; - #[link_name = "\x01?implementation@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_implementation: *mut nsIAtom; - #[link_name = "\x01?implements@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_implements: *mut nsIAtom; - #[link_name = "\x01?import@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_import: *mut nsIAtom; - #[link_name = "\x01?inactivetitlebarcolor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_inactivetitlebarcolor: *mut nsIAtom; - #[link_name = "\x01?include@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_include: *mut nsIAtom; - #[link_name = "\x01?includes@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_includes: *mut nsIAtom; - #[link_name = "\x01?increment@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_increment: *mut nsIAtom; - #[link_name = "\x01?indent@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_indent: *mut nsIAtom; - #[link_name = "\x01?indeterminate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_indeterminate: *mut nsIAtom; - #[link_name = "\x01?index@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_index: *mut nsIAtom; - #[link_name = "\x01?infer@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_infer: *mut nsIAtom; - #[link_name = "\x01?infinity@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_infinity: *mut nsIAtom; - #[link_name = "\x01?inherit@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_inherit: *mut nsIAtom; - #[link_name = "\x01?inherits@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_inherits: *mut nsIAtom; - #[link_name = "\x01?inheritstyle@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_inheritstyle: *mut nsIAtom; - #[link_name = "\x01?initial_scale@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_initial_scale: *mut nsIAtom; - #[link_name = "\x01?input@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_input: *mut nsIAtom; - #[link_name = "\x01?inputmode@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_inputmode: *mut nsIAtom; - #[link_name = "\x01?ins@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ins: *mut nsIAtom; - #[link_name = "\x01?insertafter@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_insertafter: *mut nsIAtom; - #[link_name = "\x01?insertbefore@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_insertbefore: *mut nsIAtom; - #[link_name = "\x01?install@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_install: *mut nsIAtom; - #[link_name = "\x01?instanceOf@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_instanceOf: *mut nsIAtom; - #[link_name = "\x01?int32@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_int32: *mut nsIAtom; - #[link_name = "\x01?int64@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_int64: *mut nsIAtom; - #[link_name = "\x01?integer@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_integer: *mut nsIAtom; - #[link_name = "\x01?integrity@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_integrity: *mut nsIAtom; - #[link_name = "\x01?intersection@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_intersection: *mut nsIAtom; - #[link_name = "\x01?is@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_is: *mut nsIAtom; - #[link_name = "\x01?iscontainer@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_iscontainer: *mut nsIAtom; - #[link_name = "\x01?isempty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_isempty: *mut nsIAtom; - #[link_name = "\x01?ismap@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ismap: *mut nsIAtom; - #[link_name = "\x01?itemid@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_itemid: *mut nsIAtom; - #[link_name = "\x01?itemprop@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_itemprop: *mut nsIAtom; - #[link_name = "\x01?itemref@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_itemref: *mut nsIAtom; - #[link_name = "\x01?itemscope@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_itemscope: *mut nsIAtom; - #[link_name = "\x01?itemtype@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_itemtype: *mut nsIAtom; - #[link_name = "\x01?japanese_formal@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_japanese_formal: *mut nsIAtom; - #[link_name = "\x01?japanese_informal@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_japanese_informal: *mut nsIAtom; - #[link_name = "\x01?kbd@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_kbd: *mut nsIAtom; - #[link_name = "\x01?keepcurrentinview@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_keepcurrentinview: *mut nsIAtom; - #[link_name = "\x01?keepobjectsalive@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_keepobjectsalive: *mut nsIAtom; - #[link_name = "\x01?key@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_key: *mut nsIAtom; - #[link_name = "\x01?keycode@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_keycode: *mut nsIAtom; - #[link_name = "\x01?keystatuseschange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_keystatuseschange: *mut nsIAtom; - #[link_name = "\x01?keydown@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_keydown: *mut nsIAtom; - #[link_name = "\x01?keygen@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_keygen: *mut nsIAtom; - #[link_name = "\x01?keypress@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_keypress: *mut nsIAtom; - #[link_name = "\x01?keyset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_keyset: *mut nsIAtom; - #[link_name = "\x01?keysystem@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_keysystem: *mut nsIAtom; - #[link_name = "\x01?keytext@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_keytext: *mut nsIAtom; - #[link_name = "\x01?keyup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_keyup: *mut nsIAtom; - #[link_name = "\x01?kind@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_kind: *mut nsIAtom; - #[link_name = "\x01?korean_hangul_formal@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_korean_hangul_formal: *mut nsIAtom; - #[link_name = "\x01?korean_hanja_formal@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_korean_hanja_formal: *mut nsIAtom; - #[link_name = "\x01?korean_hanja_informal@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_korean_hanja_informal: *mut nsIAtom; - #[link_name = "\x01?label@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_label: *mut nsIAtom; - #[link_name = "\x01?labels@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_labels: *mut nsIAtom; - #[link_name = "\x01?lang@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lang: *mut nsIAtom; - #[link_name = "\x01?language@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_language: *mut nsIAtom; - #[link_name = "\x01?last@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_last: *mut nsIAtom; - #[link_name = "\x01?layer@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_layer: *mut nsIAtom; - #[link_name = "\x01?LayerActivity@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_LayerActivity: *mut nsIAtom; - #[link_name = "\x01?layout@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_layout: *mut nsIAtom; - #[link_name = "\x01?leading@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_leading: *mut nsIAtom; - #[link_name = "\x01?leaf@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_leaf: *mut nsIAtom; - #[link_name = "\x01?left@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_left: *mut nsIAtom; - #[link_name = "\x01?leftmargin@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_leftmargin: *mut nsIAtom; - #[link_name = "\x01?leftpadding@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_leftpadding: *mut nsIAtom; - #[link_name = "\x01?legend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_legend: *mut nsIAtom; - #[link_name = "\x01?length@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_length: *mut nsIAtom; - #[link_name = "\x01?letterValue@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_letterValue: *mut nsIAtom; - #[link_name = "\x01?level@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_level: *mut nsIAtom; - #[link_name = "\x01?li@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_li: *mut nsIAtom; - #[link_name = "\x01?line@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_line: *mut nsIAtom; - #[link_name = "\x01?link@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_link: *mut nsIAtom; - #[link_name = "\x01?list@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_list: *mut nsIAtom; - #[link_name = "\x01?listbox@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_listbox: *mut nsIAtom; - #[link_name = "\x01?listboxbody@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_listboxbody: *mut nsIAtom; - #[link_name = "\x01?listcell@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_listcell: *mut nsIAtom; - #[link_name = "\x01?listcol@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_listcol: *mut nsIAtom; - #[link_name = "\x01?listcols@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_listcols: *mut nsIAtom; - #[link_name = "\x01?listener@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_listener: *mut nsIAtom; - #[link_name = "\x01?listhead@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_listhead: *mut nsIAtom; - #[link_name = "\x01?listheader@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_listheader: *mut nsIAtom; - #[link_name = "\x01?listing@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_listing: *mut nsIAtom; - #[link_name = "\x01?listitem@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_listitem: *mut nsIAtom; - #[link_name = "\x01?listrows@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_listrows: *mut nsIAtom; - #[link_name = "\x01?load@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_load: *mut nsIAtom; - #[link_name = "\x01?loadingprincipal@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_loadingprincipal: *mut nsIAtom; - #[link_name = "\x01?localedir@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_localedir: *mut nsIAtom; - #[link_name = "\x01?localName@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_localName: *mut nsIAtom; - #[link_name = "\x01?longdesc@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_longdesc: *mut nsIAtom; - #[link_name = "\x01?loop@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_loop: *mut nsIAtom; - #[link_name = "\x01?low@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_low: *mut nsIAtom; - #[link_name = "\x01?lowerAlpha@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lowerAlpha: *mut nsIAtom; - #[link_name = "\x01?lowerFirst@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lowerFirst: *mut nsIAtom; - #[link_name = "\x01?lowerRoman@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lowerRoman: *mut nsIAtom; - #[link_name = "\x01?lowest@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lowest: *mut nsIAtom; - #[link_name = "\x01?lowsrc@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lowsrc: *mut nsIAtom; - #[link_name = "\x01?ltr@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ltr: *mut nsIAtom; - #[link_name = "\x01?lwtheme@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lwtheme: *mut nsIAtom; - #[link_name = "\x01?lwthemetextcolor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lwthemetextcolor: *mut nsIAtom; - #[link_name = "\x01?main@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_main: *mut nsIAtom; - #[link_name = "\x01?map@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_map: *mut nsIAtom; - #[link_name = "\x01?manifest@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_manifest: *mut nsIAtom; - #[link_name = "\x01?marginBottom@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_marginBottom: *mut nsIAtom; - #[link_name = "\x01?marginLeft@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_marginLeft: *mut nsIAtom; - #[link_name = "\x01?marginRight@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_marginRight: *mut nsIAtom; - #[link_name = "\x01?marginTop@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_marginTop: *mut nsIAtom; - #[link_name = "\x01?marginheight@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_marginheight: *mut nsIAtom; - #[link_name = "\x01?marginwidth@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_marginwidth: *mut nsIAtom; - #[link_name = "\x01?mark@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mark: *mut nsIAtom; - #[link_name = "\x01?marquee@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_marquee: *mut nsIAtom; - #[link_name = "\x01?match@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_match: *mut nsIAtom; - #[link_name = "\x01?max@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_max: *mut nsIAtom; - #[link_name = "\x01?maxheight@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_maxheight: *mut nsIAtom; - #[link_name = "\x01?maximum_scale@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_maximum_scale: *mut nsIAtom; - #[link_name = "\x01?maxlength@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_maxlength: *mut nsIAtom; - #[link_name = "\x01?maxpos@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_maxpos: *mut nsIAtom; - #[link_name = "\x01?maxwidth@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_maxwidth: *mut nsIAtom; - #[link_name = "\x01?mayscript@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mayscript: *mut nsIAtom; - #[link_name = "\x01?media@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_media: *mut nsIAtom; - #[link_name = "\x01?mediaType@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mediaType: *mut nsIAtom; - #[link_name = "\x01?member@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_member: *mut nsIAtom; - #[link_name = "\x01?menu@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_menu: *mut nsIAtom; - #[link_name = "\x01?menubar@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_menubar: *mut nsIAtom; - #[link_name = "\x01?menubutton@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_menubutton: *mut nsIAtom; - #[link_name = "\x01?menuButton@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_menuButton: *mut nsIAtom; - #[link_name = "\x01?menugroup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_menugroup: *mut nsIAtom; - #[link_name = "\x01?menuitem@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_menuitem: *mut nsIAtom; - #[link_name = "\x01?menulist@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_menulist: *mut nsIAtom; - #[link_name = "\x01?menupopup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_menupopup: *mut nsIAtom; - #[link_name = "\x01?menuseparator@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_menuseparator: *mut nsIAtom; - #[link_name = "\x01?message@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_message: *mut nsIAtom; - #[link_name = "\x01?meta@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_meta: *mut nsIAtom; - #[link_name = "\x01?referrer@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_referrer: *mut nsIAtom; - #[link_name = "\x01?referrerpolicy@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_referrerpolicy: *mut nsIAtom; - #[link_name = "\x01?headerReferrerPolicy@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_headerReferrerPolicy: *mut nsIAtom; - #[link_name = "\x01?meter@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_meter: *mut nsIAtom; - #[link_name = "\x01?method@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_method: *mut nsIAtom; - #[link_name = "\x01?middle@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_middle: *mut nsIAtom; - #[link_name = "\x01?min@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_min: *mut nsIAtom; - #[link_name = "\x01?minheight@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_minheight: *mut nsIAtom; - #[link_name = "\x01?minimum_scale@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_minimum_scale: *mut nsIAtom; - #[link_name = "\x01?minlength@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_minlength: *mut nsIAtom; - #[link_name = "\x01?minpos@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_minpos: *mut nsIAtom; - #[link_name = "\x01?minusSign@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_minusSign: *mut nsIAtom; - #[link_name = "\x01?minwidth@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_minwidth: *mut nsIAtom; - #[link_name = "\x01?_mixed@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__mixed: *mut nsIAtom; - #[link_name = "\x01?messagemanagergroup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_messagemanagergroup: *mut nsIAtom; - #[link_name = "\x01?mod@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mod: *mut nsIAtom; - #[link_name = "\x01?mode@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mode: *mut nsIAtom; - #[link_name = "\x01?modifiers@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_modifiers: *mut nsIAtom; - #[link_name = "\x01?monochrome@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_monochrome: *mut nsIAtom; - #[link_name = "\x01?mousedown@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mousedown: *mut nsIAtom; - #[link_name = "\x01?mousemove@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mousemove: *mut nsIAtom; - #[link_name = "\x01?mouseout@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mouseout: *mut nsIAtom; - #[link_name = "\x01?mouseover@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mouseover: *mut nsIAtom; - #[link_name = "\x01?mousethrough@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mousethrough: *mut nsIAtom; - #[link_name = "\x01?mouseup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mouseup: *mut nsIAtom; - #[link_name = "\x01?mozfullscreenchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozfullscreenchange: *mut nsIAtom; - #[link_name = "\x01?mozfullscreenerror@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozfullscreenerror: *mut nsIAtom; - #[link_name = "\x01?mozpointerlockchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozpointerlockchange: *mut nsIAtom; - #[link_name = "\x01?mozpointerlockerror@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozpointerlockerror: *mut nsIAtom; - #[link_name = "\x01?mozprivatebrowsing@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozprivatebrowsing: *mut nsIAtom; - #[link_name = "\x01?moz_opaque@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_moz_opaque: *mut nsIAtom; - #[link_name = "\x01?moz_action_hint@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_moz_action_hint: *mut nsIAtom; - #[link_name = "\x01?x_moz_errormessage@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x_moz_errormessage: *mut nsIAtom; - #[link_name = "\x01?multicol@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_multicol: *mut nsIAtom; - #[link_name = "\x01?multiple@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_multiple: *mut nsIAtom; - #[link_name = "\x01?muted@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_muted: *mut nsIAtom; - #[link_name = "\x01?name@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_name: *mut nsIAtom; - #[link_name = "\x01?_namespace@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__namespace: *mut nsIAtom; - #[link_name = "\x01?namespaceAlias@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_namespaceAlias: *mut nsIAtom; - #[link_name = "\x01?namespaceUri@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_namespaceUri: *mut nsIAtom; - #[link_name = "\x01?NaN@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_NaN: *mut nsIAtom; - #[link_name = "\x01?nativeAnonymousChildList@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nativeAnonymousChildList: *mut nsIAtom; - #[link_name = "\x01?nav@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nav: *mut nsIAtom; - #[link_name = "\x01?negate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_negate: *mut nsIAtom; - #[link_name = "\x01?never@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_never: *mut nsIAtom; - #[link_name = "\x01?_new@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__new: *mut nsIAtom; - #[link_name = "\x01?newline@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_newline: *mut nsIAtom; - #[link_name = "\x01?nextBidi@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nextBidi: *mut nsIAtom; - #[link_name = "\x01?nextTabParentId@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nextTabParentId: *mut nsIAtom; - #[link_name = "\x01?no@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_no: *mut nsIAtom; - #[link_name = "\x01?noautofocus@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_noautofocus: *mut nsIAtom; - #[link_name = "\x01?noautohide@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_noautohide: *mut nsIAtom; - #[link_name = "\x01?norolluponanchor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_norolluponanchor: *mut nsIAtom; - #[link_name = "\x01?nobr@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nobr: *mut nsIAtom; - #[link_name = "\x01?node@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_node: *mut nsIAtom; - #[link_name = "\x01?nodefaultsrc@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nodefaultsrc: *mut nsIAtom; - #[link_name = "\x01?nodeSet@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nodeSet: *mut nsIAtom; - #[link_name = "\x01?noembed@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_noembed: *mut nsIAtom; - #[link_name = "\x01?noframes@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_noframes: *mut nsIAtom; - #[link_name = "\x01?nohref@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nohref: *mut nsIAtom; - #[link_name = "\x01?noisolation@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_noisolation: *mut nsIAtom; - #[link_name = "\x01?nomodule@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nomodule: *mut nsIAtom; - #[link_name = "\x01?nonce@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nonce: *mut nsIAtom; - #[link_name = "\x01?none@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_none: *mut nsIAtom; - #[link_name = "\x01?noresize@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_noresize: *mut nsIAtom; - #[link_name = "\x01?normal@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_normal: *mut nsIAtom; - #[link_name = "\x01?normalizeSpace@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_normalizeSpace: *mut nsIAtom; - #[link_name = "\x01?noscript@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_noscript: *mut nsIAtom; - #[link_name = "\x01?noshade@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_noshade: *mut nsIAtom; - #[link_name = "\x01?novalidate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_novalidate: *mut nsIAtom; - #[link_name = "\x01?_not@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__not: *mut nsIAtom; - #[link_name = "\x01?nowrap@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nowrap: *mut nsIAtom; - #[link_name = "\x01?number@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_number: *mut nsIAtom; - #[link_name = "\x01?null@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_null: *mut nsIAtom; - #[link_name = "\x01?object@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_object: *mut nsIAtom; - #[link_name = "\x01?objectType@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_objectType: *mut nsIAtom; - #[link_name = "\x01?observer@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_observer: *mut nsIAtom; - #[link_name = "\x01?observes@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_observes: *mut nsIAtom; - #[link_name = "\x01?odd@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_odd: *mut nsIAtom; - #[link_name = "\x01?OFF@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_OFF: *mut nsIAtom; - #[link_name = "\x01?ol@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ol: *mut nsIAtom; - #[link_name = "\x01?omitXmlDeclaration@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_omitXmlDeclaration: *mut nsIAtom; - #[link_name = "\x01?ona2dpstatuschanged@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ona2dpstatuschanged: *mut nsIAtom; - #[link_name = "\x01?onabort@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onabort: *mut nsIAtom; - #[link_name = "\x01?onmozaccesskeynotfound@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmozaccesskeynotfound: *mut nsIAtom; - #[link_name = "\x01?onactivate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onactivate: *mut nsIAtom; - #[link_name = "\x01?onadapteradded@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onadapteradded: *mut nsIAtom; - #[link_name = "\x01?onadapterremoved@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onadapterremoved: *mut nsIAtom; - #[link_name = "\x01?onafterprint@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onafterprint: *mut nsIAtom; - #[link_name = "\x01?onafterscriptexecute@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onafterscriptexecute: *mut nsIAtom; - #[link_name = "\x01?onalerting@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onalerting: *mut nsIAtom; - #[link_name = "\x01?onanimationcancel@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onanimationcancel: *mut nsIAtom; - #[link_name = "\x01?onanimationend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onanimationend: *mut nsIAtom; - #[link_name = "\x01?onanimationiteration@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onanimationiteration: *mut nsIAtom; - #[link_name = "\x01?onanimationstart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onanimationstart: *mut nsIAtom; - #[link_name = "\x01?onantennaavailablechange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onantennaavailablechange: *mut nsIAtom; - #[link_name = "\x01?onAppCommand@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onAppCommand: *mut nsIAtom; - #[link_name = "\x01?onappinstalled@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onappinstalled: *mut nsIAtom; - #[link_name = "\x01?onattributechanged@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onattributechanged: *mut nsIAtom; - #[link_name = "\x01?onattributereadreq@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onattributereadreq: *mut nsIAtom; - #[link_name = "\x01?onattributewritereq@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onattributewritereq: *mut nsIAtom; - #[link_name = "\x01?onaudioprocess@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onaudioprocess: *mut nsIAtom; - #[link_name = "\x01?onauxclick@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onauxclick: *mut nsIAtom; - #[link_name = "\x01?onbeforecopy@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onbeforecopy: *mut nsIAtom; - #[link_name = "\x01?onbeforecut@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onbeforecut: *mut nsIAtom; - #[link_name = "\x01?onbeforepaste@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onbeforepaste: *mut nsIAtom; - #[link_name = "\x01?onbeforeevicted@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onbeforeevicted: *mut nsIAtom; - #[link_name = "\x01?onbeforeprint@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onbeforeprint: *mut nsIAtom; - #[link_name = "\x01?onbeforescriptexecute@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onbeforescriptexecute: *mut nsIAtom; - #[link_name = "\x01?onbeforeunload@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onbeforeunload: *mut nsIAtom; - #[link_name = "\x01?onblocked@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onblocked: *mut nsIAtom; - #[link_name = "\x01?onblur@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onblur: *mut nsIAtom; - #[link_name = "\x01?onbroadcast@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onbroadcast: *mut nsIAtom; - #[link_name = "\x01?onbusy@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onbusy: *mut nsIAtom; - #[link_name = "\x01?onbufferedamountlow@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onbufferedamountlow: *mut nsIAtom; - #[link_name = "\x01?oncached@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncached: *mut nsIAtom; - #[link_name = "\x01?oncallschanged@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncallschanged: *mut nsIAtom; - #[link_name = "\x01?oncancel@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncancel: *mut nsIAtom; - #[link_name = "\x01?oncardstatechange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncardstatechange: *mut nsIAtom; - #[link_name = "\x01?oncfstatechange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncfstatechange: *mut nsIAtom; - #[link_name = "\x01?onchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onchange: *mut nsIAtom; - #[link_name = "\x01?oncharacteristicchanged@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncharacteristicchanged: *mut nsIAtom; - #[link_name = "\x01?onchargingchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onchargingchange: *mut nsIAtom; - #[link_name = "\x01?onchargingtimechange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onchargingtimechange: *mut nsIAtom; - #[link_name = "\x01?onchecking@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onchecking: *mut nsIAtom; - #[link_name = "\x01?onCheckboxStateChange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onCheckboxStateChange: *mut nsIAtom; - #[link_name = "\x01?onclick@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onclick: *mut nsIAtom; - #[link_name = "\x01?onclirmodechange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onclirmodechange: *mut nsIAtom; - #[link_name = "\x01?onclose@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onclose: *mut nsIAtom; - #[link_name = "\x01?oncommand@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncommand: *mut nsIAtom; - #[link_name = "\x01?oncommandupdate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncommandupdate: *mut nsIAtom; - #[link_name = "\x01?oncomplete@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncomplete: *mut nsIAtom; - #[link_name = "\x01?oncompositionend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncompositionend: *mut nsIAtom; - #[link_name = "\x01?oncompositionstart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncompositionstart: *mut nsIAtom; - #[link_name = "\x01?oncompositionupdate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncompositionupdate: *mut nsIAtom; - #[link_name = "\x01?onconnect@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onconnect: *mut nsIAtom; - #[link_name = "\x01?onconnected@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onconnected: *mut nsIAtom; - #[link_name = "\x01?onconnecting@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onconnecting: *mut nsIAtom; - #[link_name = "\x01?onconnectionavailable@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onconnectionavailable: *mut nsIAtom; - #[link_name = "\x01?onconnectionstatechanged@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onconnectionstatechanged: *mut nsIAtom; - #[link_name = "\x01?oncontextmenu@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncontextmenu: *mut nsIAtom; - #[link_name = "\x01?oncopy@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncopy: *mut nsIAtom; - #[link_name = "\x01?oncurrentchannelchanged@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncurrentchannelchanged: *mut nsIAtom; - #[link_name = "\x01?oncurrentsourcechanged@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncurrentsourcechanged: *mut nsIAtom; - #[link_name = "\x01?oncut@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncut: *mut nsIAtom; - #[link_name = "\x01?ondatachange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondatachange: *mut nsIAtom; - #[link_name = "\x01?ondataerror@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondataerror: *mut nsIAtom; - #[link_name = "\x01?ondblclick@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondblclick: *mut nsIAtom; - #[link_name = "\x01?ondeleted@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondeleted: *mut nsIAtom; - #[link_name = "\x01?ondeliverysuccess@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondeliverysuccess: *mut nsIAtom; - #[link_name = "\x01?ondeliveryerror@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondeliveryerror: *mut nsIAtom; - #[link_name = "\x01?ondevicefound@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondevicefound: *mut nsIAtom; - #[link_name = "\x01?ondevicepaired@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondevicepaired: *mut nsIAtom; - #[link_name = "\x01?ondeviceunpaired@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondeviceunpaired: *mut nsIAtom; - #[link_name = "\x01?ondialing@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondialing: *mut nsIAtom; - #[link_name = "\x01?ondisabled@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondisabled: *mut nsIAtom; - #[link_name = "\x01?ondischargingtimechange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondischargingtimechange: *mut nsIAtom; - #[link_name = "\x01?ondisconnect@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondisconnect: *mut nsIAtom; - #[link_name = "\x01?ondisconnected@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondisconnected: *mut nsIAtom; - #[link_name = "\x01?ondisconnecting@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondisconnecting: *mut nsIAtom; - #[link_name = "\x01?ondisplaypasskeyreq@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondisplaypasskeyreq: *mut nsIAtom; - #[link_name = "\x01?ondownloading@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondownloading: *mut nsIAtom; - #[link_name = "\x01?onDOMActivate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onDOMActivate: *mut nsIAtom; - #[link_name = "\x01?onDOMAttrModified@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onDOMAttrModified: *mut nsIAtom; - #[link_name = "\x01?onDOMCharacterDataModified@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onDOMCharacterDataModified: *mut nsIAtom; - #[link_name = "\x01?onDOMFocusIn@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onDOMFocusIn: *mut nsIAtom; - #[link_name = "\x01?onDOMFocusOut@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onDOMFocusOut: *mut nsIAtom; - #[link_name = "\x01?onDOMMouseScroll@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onDOMMouseScroll: *mut nsIAtom; - #[link_name = "\x01?onDOMNodeInserted@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onDOMNodeInserted: *mut nsIAtom; - #[link_name = "\x01?onDOMNodeInsertedIntoDocument@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onDOMNodeInsertedIntoDocument: *mut nsIAtom; - #[link_name = "\x01?onDOMNodeRemoved@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onDOMNodeRemoved: *mut nsIAtom; - #[link_name = "\x01?onDOMNodeRemovedFromDocument@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onDOMNodeRemovedFromDocument: *mut nsIAtom; - #[link_name = "\x01?onDOMSubtreeModified@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onDOMSubtreeModified: *mut nsIAtom; - #[link_name = "\x01?ondata@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondata: *mut nsIAtom; - #[link_name = "\x01?ondrag@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondrag: *mut nsIAtom; - #[link_name = "\x01?ondragdrop@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondragdrop: *mut nsIAtom; - #[link_name = "\x01?ondragend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondragend: *mut nsIAtom; - #[link_name = "\x01?ondragenter@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondragenter: *mut nsIAtom; - #[link_name = "\x01?ondragexit@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondragexit: *mut nsIAtom; - #[link_name = "\x01?ondraggesture@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondraggesture: *mut nsIAtom; - #[link_name = "\x01?ondragleave@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondragleave: *mut nsIAtom; - #[link_name = "\x01?ondragover@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondragover: *mut nsIAtom; - #[link_name = "\x01?ondragstart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondragstart: *mut nsIAtom; - #[link_name = "\x01?ondrain@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondrain: *mut nsIAtom; - #[link_name = "\x01?ondrop@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondrop: *mut nsIAtom; - #[link_name = "\x01?oneitbroadcasted@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oneitbroadcasted: *mut nsIAtom; - #[link_name = "\x01?onenabled@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onenabled: *mut nsIAtom; - #[link_name = "\x01?onenterpincodereq@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onenterpincodereq: *mut nsIAtom; - #[link_name = "\x01?onemergencycbmodechange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onemergencycbmodechange: *mut nsIAtom; - #[link_name = "\x01?onerror@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onerror: *mut nsIAtom; - #[link_name = "\x01?onevicted@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onevicted: *mut nsIAtom; - #[link_name = "\x01?onfailed@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onfailed: *mut nsIAtom; - #[link_name = "\x01?onfetch@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onfetch: *mut nsIAtom; - #[link_name = "\x01?onfinish@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onfinish: *mut nsIAtom; - #[link_name = "\x01?onfocus@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onfocus: *mut nsIAtom; - #[link_name = "\x01?onfocusin@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onfocusin: *mut nsIAtom; - #[link_name = "\x01?onfocusout@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onfocusout: *mut nsIAtom; - #[link_name = "\x01?onfrequencychange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onfrequencychange: *mut nsIAtom; - #[link_name = "\x01?onfullscreenchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onfullscreenchange: *mut nsIAtom; - #[link_name = "\x01?onfullscreenerror@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onfullscreenerror: *mut nsIAtom; - #[link_name = "\x01?onspeakerforcedchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onspeakerforcedchange: *mut nsIAtom; - #[link_name = "\x01?onget@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onget: *mut nsIAtom; - #[link_name = "\x01?ongroupchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ongroupchange: *mut nsIAtom; - #[link_name = "\x01?onhashchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onhashchange: *mut nsIAtom; - #[link_name = "\x01?onheadphoneschange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onheadphoneschange: *mut nsIAtom; - #[link_name = "\x01?onheld@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onheld: *mut nsIAtom; - #[link_name = "\x01?onhfpstatuschanged@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onhfpstatuschanged: *mut nsIAtom; - #[link_name = "\x01?onhidstatuschanged@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onhidstatuschanged: *mut nsIAtom; - #[link_name = "\x01?onholding@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onholding: *mut nsIAtom; - #[link_name = "\x01?oniccchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oniccchange: *mut nsIAtom; - #[link_name = "\x01?oniccdetected@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oniccdetected: *mut nsIAtom; - #[link_name = "\x01?oniccinfochange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oniccinfochange: *mut nsIAtom; - #[link_name = "\x01?oniccundetected@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oniccundetected: *mut nsIAtom; - #[link_name = "\x01?onincoming@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onincoming: *mut nsIAtom; - #[link_name = "\x01?oninput@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oninput: *mut nsIAtom; - #[link_name = "\x01?oninstall@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oninstall: *mut nsIAtom; - #[link_name = "\x01?oninvalid@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oninvalid: *mut nsIAtom; - #[link_name = "\x01?onkeydown@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onkeydown: *mut nsIAtom; - #[link_name = "\x01?onkeypress@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onkeypress: *mut nsIAtom; - #[link_name = "\x01?onkeyup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onkeyup: *mut nsIAtom; - #[link_name = "\x01?onlanguagechange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onlanguagechange: *mut nsIAtom; - #[link_name = "\x01?onlevelchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onlevelchange: *mut nsIAtom; - #[link_name = "\x01?onLoad@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onLoad: *mut nsIAtom; - #[link_name = "\x01?onload@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onload: *mut nsIAtom; - #[link_name = "\x01?onloading@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onloading: *mut nsIAtom; - #[link_name = "\x01?onloadingdone@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onloadingdone: *mut nsIAtom; - #[link_name = "\x01?onloadingerror@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onloadingerror: *mut nsIAtom; - #[link_name = "\x01?onpopstate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpopstate: *mut nsIAtom; - #[link_name = "\x01?only@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_only: *mut nsIAtom; - #[link_name = "\x01?onmessage@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmessage: *mut nsIAtom; - #[link_name = "\x01?onmessageerror@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmessageerror: *mut nsIAtom; - #[link_name = "\x01?onmousedown@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmousedown: *mut nsIAtom; - #[link_name = "\x01?onmouseenter@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmouseenter: *mut nsIAtom; - #[link_name = "\x01?onmouseleave@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmouseleave: *mut nsIAtom; - #[link_name = "\x01?onmouselongtap@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmouselongtap: *mut nsIAtom; - #[link_name = "\x01?onmousemove@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmousemove: *mut nsIAtom; - #[link_name = "\x01?onmouseout@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmouseout: *mut nsIAtom; - #[link_name = "\x01?onmouseover@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmouseover: *mut nsIAtom; - #[link_name = "\x01?onMozMouseHittest@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onMozMouseHittest: *mut nsIAtom; - #[link_name = "\x01?onmouseup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmouseup: *mut nsIAtom; - #[link_name = "\x01?onMozAfterPaint@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onMozAfterPaint: *mut nsIAtom; - #[link_name = "\x01?onmozfullscreenchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmozfullscreenchange: *mut nsIAtom; - #[link_name = "\x01?onmozfullscreenerror@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmozfullscreenerror: *mut nsIAtom; - #[link_name = "\x01?onmozkeydownonplugin@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmozkeydownonplugin: *mut nsIAtom; - #[link_name = "\x01?onmozkeyuponplugin@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmozkeyuponplugin: *mut nsIAtom; - #[link_name = "\x01?onmozpointerlockchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmozpointerlockchange: *mut nsIAtom; - #[link_name = "\x01?onmozpointerlockerror@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmozpointerlockerror: *mut nsIAtom; - #[link_name = "\x01?onMozMousePixelScroll@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onMozMousePixelScroll: *mut nsIAtom; - #[link_name = "\x01?onMozScrolledAreaChanged@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onMozScrolledAreaChanged: *mut nsIAtom; - #[link_name = "\x01?onmapfolderlistingreq@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmapfolderlistingreq: *mut nsIAtom; - #[link_name = "\x01?onmapmessageslistingreq@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmapmessageslistingreq: *mut nsIAtom; - #[link_name = "\x01?onmapgetmessagereq@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmapgetmessagereq: *mut nsIAtom; - #[link_name = "\x01?onmapsetmessagestatusreq@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmapsetmessagestatusreq: *mut nsIAtom; - #[link_name = "\x01?onmapsendmessagereq@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmapsendmessagereq: *mut nsIAtom; - #[link_name = "\x01?onmapmessageupdatereq@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmapmessageupdatereq: *mut nsIAtom; - #[link_name = "\x01?onnewrdsgroup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onnewrdsgroup: *mut nsIAtom; - #[link_name = "\x01?onnotificationclick@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onnotificationclick: *mut nsIAtom; - #[link_name = "\x01?onnotificationclose@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onnotificationclose: *mut nsIAtom; - #[link_name = "\x01?onnoupdate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onnoupdate: *mut nsIAtom; - #[link_name = "\x01?onobexpasswordreq@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onobexpasswordreq: *mut nsIAtom; - #[link_name = "\x01?onobsolete@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onobsolete: *mut nsIAtom; - #[link_name = "\x01?ononline@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ononline: *mut nsIAtom; - #[link_name = "\x01?onoffline@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onoffline: *mut nsIAtom; - #[link_name = "\x01?onopen@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onopen: *mut nsIAtom; - #[link_name = "\x01?onorientationchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onorientationchange: *mut nsIAtom; - #[link_name = "\x01?onotastatuschange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onotastatuschange: *mut nsIAtom; - #[link_name = "\x01?onoverflow@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onoverflow: *mut nsIAtom; - #[link_name = "\x01?onoverflowchanged@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onoverflowchanged: *mut nsIAtom; - #[link_name = "\x01?onpagehide@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpagehide: *mut nsIAtom; - #[link_name = "\x01?onpageshow@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpageshow: *mut nsIAtom; - #[link_name = "\x01?onpaint@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpaint: *mut nsIAtom; - #[link_name = "\x01?onpairingaborted@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpairingaborted: *mut nsIAtom; - #[link_name = "\x01?onpairingconfirmationreq@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpairingconfirmationreq: *mut nsIAtom; - #[link_name = "\x01?onpairingconsentreq@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpairingconsentreq: *mut nsIAtom; - #[link_name = "\x01?onpaste@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpaste: *mut nsIAtom; - #[link_name = "\x01?onpendingchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpendingchange: *mut nsIAtom; - #[link_name = "\x01?onpichange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpichange: *mut nsIAtom; - #[link_name = "\x01?onpointerlockchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpointerlockchange: *mut nsIAtom; - #[link_name = "\x01?onpointerlockerror@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpointerlockerror: *mut nsIAtom; - #[link_name = "\x01?onpopuphidden@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpopuphidden: *mut nsIAtom; - #[link_name = "\x01?onpopuphiding@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpopuphiding: *mut nsIAtom; - #[link_name = "\x01?onpopuppositioned@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpopuppositioned: *mut nsIAtom; - #[link_name = "\x01?onpopupshowing@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpopupshowing: *mut nsIAtom; - #[link_name = "\x01?onpopupshown@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpopupshown: *mut nsIAtom; - #[link_name = "\x01?onpullphonebookreq@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpullphonebookreq: *mut nsIAtom; - #[link_name = "\x01?onpullvcardentryreq@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpullvcardentryreq: *mut nsIAtom; - #[link_name = "\x01?onpullvcardlistingreq@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpullvcardlistingreq: *mut nsIAtom; - #[link_name = "\x01?onpush@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpush: *mut nsIAtom; - #[link_name = "\x01?onpushsubscriptionchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpushsubscriptionchange: *mut nsIAtom; - #[link_name = "\x01?onpschange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpschange: *mut nsIAtom; - #[link_name = "\x01?onptychange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onptychange: *mut nsIAtom; - #[link_name = "\x01?onradiostatechange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onradiostatechange: *mut nsIAtom; - #[link_name = "\x01?onRadioStateChange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onRadioStateChange: *mut nsIAtom; - #[link_name = "\x01?onrdsdisabled@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onrdsdisabled: *mut nsIAtom; - #[link_name = "\x01?onrdsenabled@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onrdsenabled: *mut nsIAtom; - #[link_name = "\x01?onreaderror@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onreaderror: *mut nsIAtom; - #[link_name = "\x01?onreadsuccess@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onreadsuccess: *mut nsIAtom; - #[link_name = "\x01?onready@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onready: *mut nsIAtom; - #[link_name = "\x01?onreadystatechange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onreadystatechange: *mut nsIAtom; - #[link_name = "\x01?onreceived@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onreceived: *mut nsIAtom; - #[link_name = "\x01?onremoteheld@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onremoteheld: *mut nsIAtom; - #[link_name = "\x01?onremoteresumed@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onremoteresumed: *mut nsIAtom; - #[link_name = "\x01?onrequestprogress@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onrequestprogress: *mut nsIAtom; - #[link_name = "\x01?onresourcetimingbufferfull@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onresourcetimingbufferfull: *mut nsIAtom; - #[link_name = "\x01?onresponseprogress@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onresponseprogress: *mut nsIAtom; - #[link_name = "\x01?onretrieving@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onretrieving: *mut nsIAtom; - #[link_name = "\x01?onRequest@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onRequest: *mut nsIAtom; - #[link_name = "\x01?onrequestmediaplaystatus@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onrequestmediaplaystatus: *mut nsIAtom; - #[link_name = "\x01?onreset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onreset: *mut nsIAtom; - #[link_name = "\x01?onresuming@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onresuming: *mut nsIAtom; - #[link_name = "\x01?onresize@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onresize: *mut nsIAtom; - #[link_name = "\x01?onrtchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onrtchange: *mut nsIAtom; - #[link_name = "\x01?onscanningstatechanged@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onscanningstatechanged: *mut nsIAtom; - #[link_name = "\x01?onscostatuschanged@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onscostatuschanged: *mut nsIAtom; - #[link_name = "\x01?onscroll@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onscroll: *mut nsIAtom; - #[link_name = "\x01?onselect@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onselect: *mut nsIAtom; - #[link_name = "\x01?onselectionchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onselectionchange: *mut nsIAtom; - #[link_name = "\x01?onselectstart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onselectstart: *mut nsIAtom; - #[link_name = "\x01?onsending@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onsending: *mut nsIAtom; - #[link_name = "\x01?onsent@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onsent: *mut nsIAtom; - #[link_name = "\x01?onset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onset: *mut nsIAtom; - #[link_name = "\x01?onshippingaddresschange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onshippingaddresschange: *mut nsIAtom; - #[link_name = "\x01?onshippingoptionchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onshippingoptionchange: *mut nsIAtom; - #[link_name = "\x01?onshow@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onshow: *mut nsIAtom; - #[link_name = "\x01?onstatechange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onstatechange: *mut nsIAtom; - #[link_name = "\x01?onstatuschanged@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onstatuschanged: *mut nsIAtom; - #[link_name = "\x01?onstkcommand@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onstkcommand: *mut nsIAtom; - #[link_name = "\x01?onstksessionend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onstksessionend: *mut nsIAtom; - #[link_name = "\x01?onstorage@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onstorage: *mut nsIAtom; - #[link_name = "\x01?onstorageareachanged@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onstorageareachanged: *mut nsIAtom; - #[link_name = "\x01?onsubmit@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onsubmit: *mut nsIAtom; - #[link_name = "\x01?onsuccess@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onsuccess: *mut nsIAtom; - #[link_name = "\x01?ontypechange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ontypechange: *mut nsIAtom; - #[link_name = "\x01?onterminate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onterminate: *mut nsIAtom; - #[link_name = "\x01?ontext@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ontext: *mut nsIAtom; - #[link_name = "\x01?ontoggle@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ontoggle: *mut nsIAtom; - #[link_name = "\x01?ontouchstart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ontouchstart: *mut nsIAtom; - #[link_name = "\x01?ontouchend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ontouchend: *mut nsIAtom; - #[link_name = "\x01?ontouchmove@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ontouchmove: *mut nsIAtom; - #[link_name = "\x01?ontouchcancel@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ontouchcancel: *mut nsIAtom; - #[link_name = "\x01?ontransitioncancel@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ontransitioncancel: *mut nsIAtom; - #[link_name = "\x01?ontransitionend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ontransitionend: *mut nsIAtom; - #[link_name = "\x01?ontransitionrun@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ontransitionrun: *mut nsIAtom; - #[link_name = "\x01?ontransitionstart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ontransitionstart: *mut nsIAtom; - #[link_name = "\x01?onunderflow@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onunderflow: *mut nsIAtom; - #[link_name = "\x01?onunload@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onunload: *mut nsIAtom; - #[link_name = "\x01?onupdatefound@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onupdatefound: *mut nsIAtom; - #[link_name = "\x01?onupdateready@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onupdateready: *mut nsIAtom; - #[link_name = "\x01?onupgradeneeded@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onupgradeneeded: *mut nsIAtom; - #[link_name = "\x01?onussdreceived@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onussdreceived: *mut nsIAtom; - #[link_name = "\x01?onversionchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onversionchange: *mut nsIAtom; - #[link_name = "\x01?onvisibilitychange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onvisibilitychange: *mut nsIAtom; - #[link_name = "\x01?onvoicechange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onvoicechange: *mut nsIAtom; - #[link_name = "\x01?onvoiceschanged@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onvoiceschanged: *mut nsIAtom; - #[link_name = "\x01?onvrdisplayactivate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onvrdisplayactivate: *mut nsIAtom; - #[link_name = "\x01?onvrdisplayconnect@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onvrdisplayconnect: *mut nsIAtom; - #[link_name = "\x01?onvrdisplaydeactivate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onvrdisplaydeactivate: *mut nsIAtom; - #[link_name = "\x01?onvrdisplaydisconnect@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onvrdisplaydisconnect: *mut nsIAtom; - #[link_name = "\x01?onvrdisplaypresentchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onvrdisplaypresentchange: *mut nsIAtom; - #[link_name = "\x01?onwebkitAnimationEnd@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onwebkitAnimationEnd: *mut nsIAtom; - #[link_name = "\x01?onwebkitAnimationIteration@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onwebkitAnimationIteration: *mut nsIAtom; - #[link_name = "\x01?onwebkitAnimationStart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onwebkitAnimationStart: *mut nsIAtom; - #[link_name = "\x01?onwebkitTransitionEnd@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onwebkitTransitionEnd: *mut nsIAtom; - #[link_name = "\x01?onwebkitanimationend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onwebkitanimationend: *mut nsIAtom; - #[link_name = "\x01?onwebkitanimationiteration@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onwebkitanimationiteration: *mut nsIAtom; - #[link_name = "\x01?onwebkitanimationstart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onwebkitanimationstart: *mut nsIAtom; - #[link_name = "\x01?onwebkittransitionend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onwebkittransitionend: *mut nsIAtom; - #[link_name = "\x01?onwebsocket@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onwebsocket: *mut nsIAtom; - #[link_name = "\x01?onwheel@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onwheel: *mut nsIAtom; - #[link_name = "\x01?open@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_open: *mut nsIAtom; - #[link_name = "\x01?optgroup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_optgroup: *mut nsIAtom; - #[link_name = "\x01?optimum@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_optimum: *mut nsIAtom; - #[link_name = "\x01?option@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_option: *mut nsIAtom; - #[link_name = "\x01?_or@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__or: *mut nsIAtom; - #[link_name = "\x01?order@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_order: *mut nsIAtom; - #[link_name = "\x01?ordinal@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ordinal: *mut nsIAtom; - #[link_name = "\x01?orient@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_orient: *mut nsIAtom; - #[link_name = "\x01?orientation@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_orientation: *mut nsIAtom; - #[link_name = "\x01?otherwise@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_otherwise: *mut nsIAtom; - #[link_name = "\x01?output@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_output: *mut nsIAtom; - #[link_name = "\x01?overflow@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_overflow: *mut nsIAtom; - #[link_name = "\x01?overflowchanged@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_overflowchanged: *mut nsIAtom; - #[link_name = "\x01?overlay@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_overlay: *mut nsIAtom; - #[link_name = "\x01?overlap@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_overlap: *mut nsIAtom; - #[link_name = "\x01?p@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_p: *mut nsIAtom; - #[link_name = "\x01?pack@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pack: *mut nsIAtom; - #[link_name = "\x01?page@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_page: *mut nsIAtom; - #[link_name = "\x01?pageincrement@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pageincrement: *mut nsIAtom; - #[link_name = "\x01?pagex@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pagex: *mut nsIAtom; - #[link_name = "\x01?pagey@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pagey: *mut nsIAtom; - #[link_name = "\x01?paint_order@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_paint_order: *mut nsIAtom; - #[link_name = "\x01?palettename@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_palettename: *mut nsIAtom; - #[link_name = "\x01?panel@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_panel: *mut nsIAtom; - #[link_name = "\x01?param@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_param: *mut nsIAtom; - #[link_name = "\x01?parameter@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_parameter: *mut nsIAtom; - #[link_name = "\x01?parent@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_parent: *mut nsIAtom; - #[link_name = "\x01?parentfocused@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_parentfocused: *mut nsIAtom; - #[link_name = "\x01?parsetype@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_parsetype: *mut nsIAtom; - #[link_name = "\x01?password@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_password: *mut nsIAtom; - #[link_name = "\x01?pattern@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pattern: *mut nsIAtom; - #[link_name = "\x01?patternSeparator@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_patternSeparator: *mut nsIAtom; - #[link_name = "\x01?perMille@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_perMille: *mut nsIAtom; - #[link_name = "\x01?percent@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_percent: *mut nsIAtom; - #[link_name = "\x01?persist@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_persist: *mut nsIAtom; - #[link_name = "\x01?phase@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_phase: *mut nsIAtom; - #[link_name = "\x01?picture@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_picture: *mut nsIAtom; - #[link_name = "\x01?ping@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ping: *mut nsIAtom; - #[link_name = "\x01?pinned@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pinned: *mut nsIAtom; - #[link_name = "\x01?placeholder@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_placeholder: *mut nsIAtom; - #[link_name = "\x01?plaintext@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_plaintext: *mut nsIAtom; - #[link_name = "\x01?playbackrate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_playbackrate: *mut nsIAtom; - #[link_name = "\x01?pointSize@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pointSize: *mut nsIAtom; - #[link_name = "\x01?pointerlockchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pointerlockchange: *mut nsIAtom; - #[link_name = "\x01?pointerlockerror@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pointerlockerror: *mut nsIAtom; - #[link_name = "\x01?poly@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_poly: *mut nsIAtom; - #[link_name = "\x01?polygon@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_polygon: *mut nsIAtom; - #[link_name = "\x01?popup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_popup: *mut nsIAtom; - #[link_name = "\x01?popupalign@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_popupalign: *mut nsIAtom; - #[link_name = "\x01?popupanchor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_popupanchor: *mut nsIAtom; - #[link_name = "\x01?popupgroup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_popupgroup: *mut nsIAtom; - #[link_name = "\x01?popuphidden@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_popuphidden: *mut nsIAtom; - #[link_name = "\x01?popuphiding@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_popuphiding: *mut nsIAtom; - #[link_name = "\x01?popupset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_popupset: *mut nsIAtom; - #[link_name = "\x01?popupshowing@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_popupshowing: *mut nsIAtom; - #[link_name = "\x01?popupshown@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_popupshown: *mut nsIAtom; - #[link_name = "\x01?popupsinherittooltip@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_popupsinherittooltip: *mut nsIAtom; - #[link_name = "\x01?position@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_position: *mut nsIAtom; - #[link_name = "\x01?poster@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_poster: *mut nsIAtom; - #[link_name = "\x01?pre@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pre: *mut nsIAtom; - #[link_name = "\x01?preceding@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_preceding: *mut nsIAtom; - #[link_name = "\x01?precedingSibling@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_precedingSibling: *mut nsIAtom; - #[link_name = "\x01?predicate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_predicate: *mut nsIAtom; - #[link_name = "\x01?prefix@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_prefix: *mut nsIAtom; - #[link_name = "\x01?preload@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_preload: *mut nsIAtom; - #[link_name = "\x01?prerendered@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_prerendered: *mut nsIAtom; - #[link_name = "\x01?mozpresentation@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozpresentation: *mut nsIAtom; - #[link_name = "\x01?preserve@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_preserve: *mut nsIAtom; - #[link_name = "\x01?preserveSpace@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_preserveSpace: *mut nsIAtom; - #[link_name = "\x01?preventdefault@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_preventdefault: *mut nsIAtom; - #[link_name = "\x01?primary@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_primary: *mut nsIAtom; - #[link_name = "\x01?print@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_print: *mut nsIAtom; - #[link_name = "\x01?priority@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_priority: *mut nsIAtom; - #[link_name = "\x01?processingInstruction@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_processingInstruction: *mut nsIAtom; - #[link_name = "\x01?profile@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_profile: *mut nsIAtom; - #[link_name = "\x01?progress@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_progress: *mut nsIAtom; - #[link_name = "\x01?progressmeter@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_progressmeter: *mut nsIAtom; - #[link_name = "\x01?progressNormal@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_progressNormal: *mut nsIAtom; - #[link_name = "\x01?progressUndetermined@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_progressUndetermined: *mut nsIAtom; - #[link_name = "\x01?projection@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_projection: *mut nsIAtom; - #[link_name = "\x01?prompt@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_prompt: *mut nsIAtom; - #[link_name = "\x01?propagate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_propagate: *mut nsIAtom; - #[link_name = "\x01?properties@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_properties: *mut nsIAtom; - #[link_name = "\x01?property@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_property: *mut nsIAtom; - #[link_name = "\x01?pubdate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pubdate: *mut nsIAtom; - #[link_name = "\x01?q@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_q: *mut nsIAtom; - #[link_name = "\x01?query@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_query: *mut nsIAtom; - #[link_name = "\x01?queryset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_queryset: *mut nsIAtom; - #[link_name = "\x01?querytype@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_querytype: *mut nsIAtom; - #[link_name = "\x01?radio@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_radio: *mut nsIAtom; - #[link_name = "\x01?radiogroup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_radiogroup: *mut nsIAtom; - #[link_name = "\x01?range@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_range: *mut nsIAtom; - #[link_name = "\x01?readonly@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_readonly: *mut nsIAtom; - #[link_name = "\x01?rect@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rect: *mut nsIAtom; - #[link_name = "\x01?rectangle@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rectangle: *mut nsIAtom; - #[link_name = "\x01?ref@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ref: *mut nsIAtom; - #[link_name = "\x01?refresh@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_refresh: *mut nsIAtom; - #[link_name = "\x01?rel@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rel: *mut nsIAtom; - #[link_name = "\x01?onreloadpage@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onreloadpage: *mut nsIAtom; - #[link_name = "\x01?rem@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rem: *mut nsIAtom; - #[link_name = "\x01?remote@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_remote: *mut nsIAtom; - #[link_name = "\x01?removeelement@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_removeelement: *mut nsIAtom; - #[link_name = "\x01?renderingobserverlist@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_renderingobserverlist: *mut nsIAtom; - #[link_name = "\x01?repeat@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_repeat: *mut nsIAtom; - #[link_name = "\x01?replace@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_replace: *mut nsIAtom; - #[link_name = "\x01?requestcontextid@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_requestcontextid: *mut nsIAtom; - #[link_name = "\x01?required@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_required: *mut nsIAtom; - #[link_name = "\x01?reserved@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_reserved: *mut nsIAtom; - #[link_name = "\x01?reset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_reset: *mut nsIAtom; - #[link_name = "\x01?resizeafter@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_resizeafter: *mut nsIAtom; - #[link_name = "\x01?resizebefore@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_resizebefore: *mut nsIAtom; - #[link_name = "\x01?resizer@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_resizer: *mut nsIAtom; - #[link_name = "\x01?resolution@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_resolution: *mut nsIAtom; - #[link_name = "\x01?resource@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_resource: *mut nsIAtom; - #[link_name = "\x01?resources@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_resources: *mut nsIAtom; - #[link_name = "\x01?result@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_result: *mut nsIAtom; - #[link_name = "\x01?resultPrefix@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_resultPrefix: *mut nsIAtom; - #[link_name = "\x01?retargetdocumentfocus@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_retargetdocumentfocus: *mut nsIAtom; - #[link_name = "\x01?rev@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rev: *mut nsIAtom; - #[link_name = "\x01?reverse@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_reverse: *mut nsIAtom; - #[link_name = "\x01?reversed@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_reversed: *mut nsIAtom; - #[link_name = "\x01?richlistbox@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_richlistbox: *mut nsIAtom; - #[link_name = "\x01?richlistitem@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_richlistitem: *mut nsIAtom; - #[link_name = "\x01?right@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_right: *mut nsIAtom; - #[link_name = "\x01?rightmargin@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rightmargin: *mut nsIAtom; - #[link_name = "\x01?rightpadding@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rightpadding: *mut nsIAtom; - #[link_name = "\x01?role@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_role: *mut nsIAtom; - #[link_name = "\x01?rolluponmousewheel@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rolluponmousewheel: *mut nsIAtom; - #[link_name = "\x01?round@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_round: *mut nsIAtom; - #[link_name = "\x01?row@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_row: *mut nsIAtom; - #[link_name = "\x01?rows@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rows: *mut nsIAtom; - #[link_name = "\x01?rowspan@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rowspan: *mut nsIAtom; - #[link_name = "\x01?rb@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rb: *mut nsIAtom; - #[link_name = "\x01?rp@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rp: *mut nsIAtom; - #[link_name = "\x01?rt@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rt: *mut nsIAtom; - #[link_name = "\x01?rtc@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rtc: *mut nsIAtom; - #[link_name = "\x01?rtl@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rtl: *mut nsIAtom; - #[link_name = "\x01?ruby@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ruby: *mut nsIAtom; - #[link_name = "\x01?rubyBase@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rubyBase: *mut nsIAtom; - #[link_name = "\x01?rubyBaseContainer@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rubyBaseContainer: *mut nsIAtom; - #[link_name = "\x01?rubyText@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rubyText: *mut nsIAtom; - #[link_name = "\x01?rubyTextContainer@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rubyTextContainer: *mut nsIAtom; - #[link_name = "\x01?rule@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rule: *mut nsIAtom; - #[link_name = "\x01?rules@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rules: *mut nsIAtom; - #[link_name = "\x01?s@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_s: *mut nsIAtom; - #[link_name = "\x01?samp@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_samp: *mut nsIAtom; - #[link_name = "\x01?sandbox@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sandbox: *mut nsIAtom; - #[link_name = "\x01?sbattr@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sbattr: *mut nsIAtom; - #[link_name = "\x01?scale@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scale: *mut nsIAtom; - #[link_name = "\x01?scan@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scan: *mut nsIAtom; - #[link_name = "\x01?scheme@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scheme: *mut nsIAtom; - #[link_name = "\x01?scope@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scope: *mut nsIAtom; - #[link_name = "\x01?scoped@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scoped: *mut nsIAtom; - #[link_name = "\x01?screen@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_screen: *mut nsIAtom; - #[link_name = "\x01?screenX@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_screenX: *mut nsIAtom; - #[link_name = "\x01?screenY@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_screenY: *mut nsIAtom; - #[link_name = "\x01?script@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_script: *mut nsIAtom; - #[link_name = "\x01?scriptEnabledBeforePrintOrPreview@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scriptEnabledBeforePrintOrPreview: *mut nsIAtom; - #[link_name = "\x01?scrollbar@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scrollbar: *mut nsIAtom; - #[link_name = "\x01?scrollbarbutton@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scrollbarbutton: *mut nsIAtom; - #[link_name = "\x01?scrollbarDownBottom@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scrollbarDownBottom: *mut nsIAtom; - #[link_name = "\x01?scrollbarDownTop@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scrollbarDownTop: *mut nsIAtom; - #[link_name = "\x01?scrollbarUpBottom@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scrollbarUpBottom: *mut nsIAtom; - #[link_name = "\x01?scrollbarUpTop@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scrollbarUpTop: *mut nsIAtom; - #[link_name = "\x01?scrollbox@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scrollbox: *mut nsIAtom; - #[link_name = "\x01?scrollcorner@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scrollcorner: *mut nsIAtom; - #[link_name = "\x01?scrolling@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scrolling: *mut nsIAtom; - #[link_name = "\x01?scrollPosition@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scrollPosition: *mut nsIAtom; - #[link_name = "\x01?section@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_section: *mut nsIAtom; - #[link_name = "\x01?select@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_select: *mut nsIAtom; - #[link_name = "\x01?selectable@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_selectable: *mut nsIAtom; - #[link_name = "\x01?selected@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_selected: *mut nsIAtom; - #[link_name = "\x01?selectedIndex@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_selectedIndex: *mut nsIAtom; - #[link_name = "\x01?selectedindex@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_selectedindex: *mut nsIAtom; - #[link_name = "\x01?self@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_self: *mut nsIAtom; - #[link_name = "\x01?seltype@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_seltype: *mut nsIAtom; - #[link_name = "\x01?setcookie@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_setcookie: *mut nsIAtom; - #[link_name = "\x01?setter@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_setter: *mut nsIAtom; - #[link_name = "\x01?shape@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_shape: *mut nsIAtom; - #[link_name = "\x01?show@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_show: *mut nsIAtom; - #[link_name = "\x01?showcaret@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_showcaret: *mut nsIAtom; - #[link_name = "\x01?showresizer@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_showresizer: *mut nsIAtom; - #[link_name = "\x01?simple@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_simple: *mut nsIAtom; - #[link_name = "\x01?simp_chinese_formal@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_simp_chinese_formal: *mut nsIAtom; - #[link_name = "\x01?simp_chinese_informal@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_simp_chinese_informal: *mut nsIAtom; - #[link_name = "\x01?single@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_single: *mut nsIAtom; - #[link_name = "\x01?size@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_size: *mut nsIAtom; - #[link_name = "\x01?sizes@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sizes: *mut nsIAtom; - #[link_name = "\x01?sizemode@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sizemode: *mut nsIAtom; - #[link_name = "\x01?sizetopopup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sizetopopup: *mut nsIAtom; - #[link_name = "\x01?slider@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_slider: *mut nsIAtom; - #[link_name = "\x01?small@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_small: *mut nsIAtom; - #[link_name = "\x01?smooth@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_smooth: *mut nsIAtom; - #[link_name = "\x01?snap@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_snap: *mut nsIAtom; - #[link_name = "\x01?sort@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sort: *mut nsIAtom; - #[link_name = "\x01?sortActive@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sortActive: *mut nsIAtom; - #[link_name = "\x01?sortDirection@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sortDirection: *mut nsIAtom; - #[link_name = "\x01?sorted@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sorted: *mut nsIAtom; - #[link_name = "\x01?sorthints@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sorthints: *mut nsIAtom; - #[link_name = "\x01?sortLocked@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sortLocked: *mut nsIAtom; - #[link_name = "\x01?sortResource@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sortResource: *mut nsIAtom; - #[link_name = "\x01?sortResource2@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sortResource2: *mut nsIAtom; - #[link_name = "\x01?sortSeparators@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sortSeparators: *mut nsIAtom; - #[link_name = "\x01?sortStaticsLast@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sortStaticsLast: *mut nsIAtom; - #[link_name = "\x01?source@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_source: *mut nsIAtom; - #[link_name = "\x01?space@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_space: *mut nsIAtom; - #[link_name = "\x01?spacer@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_spacer: *mut nsIAtom; - #[link_name = "\x01?span@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_span: *mut nsIAtom; - #[link_name = "\x01?spellcheck@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_spellcheck: *mut nsIAtom; - #[link_name = "\x01?spinner@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_spinner: *mut nsIAtom; - #[link_name = "\x01?split@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_split: *mut nsIAtom; - #[link_name = "\x01?splitter@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_splitter: *mut nsIAtom; - #[link_name = "\x01?spring@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_spring: *mut nsIAtom; - #[link_name = "\x01?square@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_square: *mut nsIAtom; - #[link_name = "\x01?src@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_src: *mut nsIAtom; - #[link_name = "\x01?srcdoc@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_srcdoc: *mut nsIAtom; - #[link_name = "\x01?srclang@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_srclang: *mut nsIAtom; - #[link_name = "\x01?srcset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_srcset: *mut nsIAtom; - #[link_name = "\x01?stack@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stack: *mut nsIAtom; - #[link_name = "\x01?standalone@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_standalone: *mut nsIAtom; - #[link_name = "\x01?standby@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_standby: *mut nsIAtom; - #[link_name = "\x01?start@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_start: *mut nsIAtom; - #[link_name = "\x01?start_after@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_start_after: *mut nsIAtom; - #[link_name = "\x01?start_before@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_start_before: *mut nsIAtom; - #[link_name = "\x01?startsWith@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_startsWith: *mut nsIAtom; - #[link_name = "\x01?state@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_state: *mut nsIAtom; - #[link_name = "\x01?statedatasource@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_statedatasource: *mut nsIAtom; - #[link_name = "\x01?staticHint@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_staticHint: *mut nsIAtom; - #[link_name = "\x01?statusbar@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_statusbar: *mut nsIAtom; - #[link_name = "\x01?statustext@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_statustext: *mut nsIAtom; - #[link_name = "\x01?step@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_step: *mut nsIAtom; - #[link_name = "\x01?stop@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stop: *mut nsIAtom; - #[link_name = "\x01?stretch@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stretch: *mut nsIAtom; - #[link_name = "\x01?strike@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_strike: *mut nsIAtom; - #[link_name = "\x01?string@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_string: *mut nsIAtom; - #[link_name = "\x01?stringLength@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stringLength: *mut nsIAtom; - #[link_name = "\x01?stripSpace@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stripSpace: *mut nsIAtom; - #[link_name = "\x01?strong@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_strong: *mut nsIAtom; - #[link_name = "\x01?style@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_style: *mut nsIAtom; - #[link_name = "\x01?stylesheet@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stylesheet: *mut nsIAtom; - #[link_name = "\x01?stylesheetPrefix@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stylesheetPrefix: *mut nsIAtom; - #[link_name = "\x01?subject@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_subject: *mut nsIAtom; - #[link_name = "\x01?submit@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_submit: *mut nsIAtom; - #[link_name = "\x01?substate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_substate: *mut nsIAtom; - #[link_name = "\x01?substring@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_substring: *mut nsIAtom; - #[link_name = "\x01?substringAfter@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_substringAfter: *mut nsIAtom; - #[link_name = "\x01?substringBefore@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_substringBefore: *mut nsIAtom; - #[link_name = "\x01?sub@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sub: *mut nsIAtom; - #[link_name = "\x01?sum@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sum: *mut nsIAtom; - #[link_name = "\x01?sup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sup: *mut nsIAtom; - #[link_name = "\x01?summary@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_summary: *mut nsIAtom; - #[link_name = "\x01?_switch@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__switch: *mut nsIAtom; - #[link_name = "\x01?systemProperty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_systemProperty: *mut nsIAtom; - #[link_name = "\x01?tab@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tab: *mut nsIAtom; - #[link_name = "\x01?tabbox@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tabbox: *mut nsIAtom; - #[link_name = "\x01?tabindex@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tabindex: *mut nsIAtom; - #[link_name = "\x01?table@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_table: *mut nsIAtom; - #[link_name = "\x01?tabpanel@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tabpanel: *mut nsIAtom; - #[link_name = "\x01?tabpanels@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tabpanels: *mut nsIAtom; - #[link_name = "\x01?tag@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tag: *mut nsIAtom; - #[link_name = "\x01?target@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_target: *mut nsIAtom; - #[link_name = "\x01?targets@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_targets: *mut nsIAtom; - #[link_name = "\x01?tbody@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tbody: *mut nsIAtom; - #[link_name = "\x01?td@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_td: *mut nsIAtom; - #[link_name = "\x01?_template@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__template: *mut nsIAtom; - #[link_name = "\x01?text_decoration@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_text_decoration: *mut nsIAtom; - #[link_name = "\x01?terminate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_terminate: *mut nsIAtom; - #[link_name = "\x01?term@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_term: *mut nsIAtom; - #[link_name = "\x01?test@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_test: *mut nsIAtom; - #[link_name = "\x01?text@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_text: *mut nsIAtom; - #[link_name = "\x01?textAlign@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_textAlign: *mut nsIAtom; - #[link_name = "\x01?textarea@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_textarea: *mut nsIAtom; - #[link_name = "\x01?textbox@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_textbox: *mut nsIAtom; - #[link_name = "\x01?textnode@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_textnode: *mut nsIAtom; - #[link_name = "\x01?textNodeDirectionalityMap@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_textNodeDirectionalityMap: *mut nsIAtom; - #[link_name = "\x01?tfoot@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tfoot: *mut nsIAtom; - #[link_name = "\x01?th@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_th: *mut nsIAtom; - #[link_name = "\x01?thead@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_thead: *mut nsIAtom; - #[link_name = "\x01?thumb@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_thumb: *mut nsIAtom; - #[link_name = "\x01?time@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_time: *mut nsIAtom; - #[link_name = "\x01?title@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_title: *mut nsIAtom; - #[link_name = "\x01?titlebar@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_titlebar: *mut nsIAtom; - #[link_name = "\x01?titletip@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_titletip: *mut nsIAtom; - #[link_name = "\x01?toggled@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_toggled: *mut nsIAtom; - #[link_name = "\x01?token@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_token: *mut nsIAtom; - #[link_name = "\x01?tokenize@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tokenize: *mut nsIAtom; - #[link_name = "\x01?toolbar@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_toolbar: *mut nsIAtom; - #[link_name = "\x01?toolbarbutton@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_toolbarbutton: *mut nsIAtom; - #[link_name = "\x01?toolbaritem@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_toolbaritem: *mut nsIAtom; - #[link_name = "\x01?toolbox@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_toolbox: *mut nsIAtom; - #[link_name = "\x01?tooltip@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tooltip: *mut nsIAtom; - #[link_name = "\x01?tooltiptext@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tooltiptext: *mut nsIAtom; - #[link_name = "\x01?top@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_top: *mut nsIAtom; - #[link_name = "\x01?topleft@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_topleft: *mut nsIAtom; - #[link_name = "\x01?topmargin@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_topmargin: *mut nsIAtom; - #[link_name = "\x01?toppadding@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_toppadding: *mut nsIAtom; - #[link_name = "\x01?topright@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_topright: *mut nsIAtom; - #[link_name = "\x01?tr@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tr: *mut nsIAtom; - #[link_name = "\x01?track@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_track: *mut nsIAtom; - #[link_name = "\x01?trad_chinese_formal@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_trad_chinese_formal: *mut nsIAtom; - #[link_name = "\x01?trad_chinese_informal@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_trad_chinese_informal: *mut nsIAtom; - #[link_name = "\x01?trailing@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_trailing: *mut nsIAtom; - #[link_name = "\x01?transform@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_transform: *mut nsIAtom; - #[link_name = "\x01?transform_3d@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_transform_3d: *mut nsIAtom; - #[link_name = "\x01?transformiix@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_transformiix: *mut nsIAtom; - #[link_name = "\x01?translate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_translate: *mut nsIAtom; - #[link_name = "\x01?transparent@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_transparent: *mut nsIAtom; - #[link_name = "\x01?tree@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tree: *mut nsIAtom; - #[link_name = "\x01?treecell@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_treecell: *mut nsIAtom; - #[link_name = "\x01?treechildren@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_treechildren: *mut nsIAtom; - #[link_name = "\x01?treecol@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_treecol: *mut nsIAtom; - #[link_name = "\x01?treecolpicker@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_treecolpicker: *mut nsIAtom; - #[link_name = "\x01?treecols@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_treecols: *mut nsIAtom; - #[link_name = "\x01?treeitem@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_treeitem: *mut nsIAtom; - #[link_name = "\x01?treerow@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_treerow: *mut nsIAtom; - #[link_name = "\x01?treeseparator@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_treeseparator: *mut nsIAtom; - #[link_name = "\x01?triple@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_triple: *mut nsIAtom; - #[link_name = "\x01?_true@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__true: *mut nsIAtom; - #[link_name = "\x01?tt@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tt: *mut nsIAtom; - #[link_name = "\x01?tty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tty: *mut nsIAtom; - #[link_name = "\x01?tv@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tv: *mut nsIAtom; - #[link_name = "\x01?type@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_type: *mut nsIAtom; - #[link_name = "\x01?typemustmatch@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_typemustmatch: *mut nsIAtom; - #[link_name = "\x01?u@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_u: *mut nsIAtom; - #[link_name = "\x01?ul@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ul: *mut nsIAtom; - #[link_name = "\x01?underflow@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_underflow: *mut nsIAtom; - #[link_name = "\x01?undetermined@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_undetermined: *mut nsIAtom; - #[link_name = "\x01?unload@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_unload: *mut nsIAtom; - #[link_name = "\x01?unparsedEntityUri@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_unparsedEntityUri: *mut nsIAtom; - #[link_name = "\x01?upperAlpha@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_upperAlpha: *mut nsIAtom; - #[link_name = "\x01?upperFirst@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_upperFirst: *mut nsIAtom; - #[link_name = "\x01?upperRoman@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_upperRoman: *mut nsIAtom; - #[link_name = "\x01?uri@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_uri: *mut nsIAtom; - #[link_name = "\x01?use@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_use: *mut nsIAtom; - #[link_name = "\x01?useAttributeSets@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_useAttributeSets: *mut nsIAtom; - #[link_name = "\x01?usemap@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_usemap: *mut nsIAtom; - #[link_name = "\x01?user_scalable@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_user_scalable: *mut nsIAtom; - #[link_name = "\x01?userInput@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_userInput: *mut nsIAtom; - #[link_name = "\x01?validate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_validate: *mut nsIAtom; - #[link_name = "\x01?valign@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_valign: *mut nsIAtom; - #[link_name = "\x01?value@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_value: *mut nsIAtom; - #[link_name = "\x01?values@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_values: *mut nsIAtom; - #[link_name = "\x01?valueOf@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_valueOf: *mut nsIAtom; - #[link_name = "\x01?valuetype@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_valuetype: *mut nsIAtom; - #[link_name = "\x01?var@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_var: *mut nsIAtom; - #[link_name = "\x01?variable@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_variable: *mut nsIAtom; - #[link_name = "\x01?vbox@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_vbox: *mut nsIAtom; - #[link_name = "\x01?vcard_name@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_vcard_name: *mut nsIAtom; - #[link_name = "\x01?vendor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_vendor: *mut nsIAtom; - #[link_name = "\x01?vendorUrl@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_vendorUrl: *mut nsIAtom; - #[link_name = "\x01?version@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_version: *mut nsIAtom; - #[link_name = "\x01?vert@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_vert: *mut nsIAtom; - #[link_name = "\x01?vertical@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_vertical: *mut nsIAtom; - #[link_name = "\x01?audio@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_audio: *mut nsIAtom; - #[link_name = "\x01?video@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_video: *mut nsIAtom; - #[link_name = "\x01?videocontrols@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_videocontrols: *mut nsIAtom; - #[link_name = "\x01?viewport@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_viewport: *mut nsIAtom; - #[link_name = "\x01?viewport_height@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_viewport_height: *mut nsIAtom; - #[link_name = "\x01?viewport_initial_scale@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_viewport_initial_scale: *mut nsIAtom; - #[link_name = "\x01?viewport_maximum_scale@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_viewport_maximum_scale: *mut nsIAtom; - #[link_name = "\x01?viewport_minimum_scale@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_viewport_minimum_scale: *mut nsIAtom; - #[link_name = "\x01?viewport_user_scalable@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_viewport_user_scalable: *mut nsIAtom; - #[link_name = "\x01?viewport_width@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_viewport_width: *mut nsIAtom; - #[link_name = "\x01?visibility@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_visibility: *mut nsIAtom; - #[link_name = "\x01?visuallyselected@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_visuallyselected: *mut nsIAtom; - #[link_name = "\x01?vlink@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_vlink: *mut nsIAtom; - #[link_name = "\x01?vspace@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_vspace: *mut nsIAtom; - #[link_name = "\x01?wbr@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_wbr: *mut nsIAtom; - #[link_name = "\x01?webkitdirectory@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_webkitdirectory: *mut nsIAtom; - #[link_name = "\x01?when@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_when: *mut nsIAtom; - #[link_name = "\x01?where@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_where: *mut nsIAtom; - #[link_name = "\x01?widget@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_widget: *mut nsIAtom; - #[link_name = "\x01?width@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_width: *mut nsIAtom; - #[link_name = "\x01?willChange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_willChange: *mut nsIAtom; - #[link_name = "\x01?window@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_window: *mut nsIAtom; - #[link_name = "\x01?headerWindowTarget@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_headerWindowTarget: *mut nsIAtom; - #[link_name = "\x01?windowtype@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_windowtype: *mut nsIAtom; - #[link_name = "\x01?withParam@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_withParam: *mut nsIAtom; - #[link_name = "\x01?wizard@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_wizard: *mut nsIAtom; - #[link_name = "\x01?wrap@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_wrap: *mut nsIAtom; - #[link_name = "\x01?headerDNSPrefetchControl@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_headerDNSPrefetchControl: *mut nsIAtom; - #[link_name = "\x01?headerCSP@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_headerCSP: *mut nsIAtom; - #[link_name = "\x01?headerCSPReportOnly@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_headerCSPReportOnly: *mut nsIAtom; - #[link_name = "\x01?headerXFO@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_headerXFO: *mut nsIAtom; - #[link_name = "\x01?x_western@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x_western: *mut nsIAtom; - #[link_name = "\x01?xml@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xml: *mut nsIAtom; - #[link_name = "\x01?xml_stylesheet@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xml_stylesheet: *mut nsIAtom; - #[link_name = "\x01?xmlns@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xmlns: *mut nsIAtom; - #[link_name = "\x01?xmp@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xmp: *mut nsIAtom; - #[link_name = "\x01?xulcontentsgenerated@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xulcontentsgenerated: *mut nsIAtom; - #[link_name = "\x01?yes@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_yes: *mut nsIAtom; - #[link_name = "\x01?z_index@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_z_index: *mut nsIAtom; - #[link_name = "\x01?zeroDigit@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_zeroDigit: *mut nsIAtom; - #[link_name = "\x01?percentage@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_percentage: *mut nsIAtom; - #[link_name = "\x01?A@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_A: *mut nsIAtom; - #[link_name = "\x01?alignment_baseline@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_alignment_baseline: *mut nsIAtom; - #[link_name = "\x01?amplitude@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_amplitude: *mut nsIAtom; - #[link_name = "\x01?animate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_animate: *mut nsIAtom; - #[link_name = "\x01?animateColor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_animateColor: *mut nsIAtom; - #[link_name = "\x01?animateMotion@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_animateMotion: *mut nsIAtom; - #[link_name = "\x01?animateTransform@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_animateTransform: *mut nsIAtom; - #[link_name = "\x01?arithmetic@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_arithmetic: *mut nsIAtom; - #[link_name = "\x01?atop@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_atop: *mut nsIAtom; - #[link_name = "\x01?azimuth@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_azimuth: *mut nsIAtom; - #[link_name = "\x01?B@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_B: *mut nsIAtom; - #[link_name = "\x01?backgroundColor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_backgroundColor: *mut nsIAtom; - #[link_name = "\x01?background_image@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_background_image: *mut nsIAtom; - #[link_name = "\x01?baseFrequency@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_baseFrequency: *mut nsIAtom; - #[link_name = "\x01?baseline_shift@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_baseline_shift: *mut nsIAtom; - #[link_name = "\x01?bias@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_bias: *mut nsIAtom; - #[link_name = "\x01?caption_side@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_caption_side: *mut nsIAtom; - #[link_name = "\x01?clip_path@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_clip_path: *mut nsIAtom; - #[link_name = "\x01?clip_rule@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_clip_rule: *mut nsIAtom; - #[link_name = "\x01?clipPath@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_clipPath: *mut nsIAtom; - #[link_name = "\x01?clipPathUnits@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_clipPathUnits: *mut nsIAtom; - #[link_name = "\x01?cm@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cm: *mut nsIAtom; - #[link_name = "\x01?colorBurn@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_colorBurn: *mut nsIAtom; - #[link_name = "\x01?colorDodge@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_colorDodge: *mut nsIAtom; - #[link_name = "\x01?colorInterpolation@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_colorInterpolation: *mut nsIAtom; - #[link_name = "\x01?colorInterpolationFilters@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_colorInterpolationFilters: *mut nsIAtom; - #[link_name = "\x01?colorProfile@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_colorProfile: *mut nsIAtom; - #[link_name = "\x01?cursor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cursor: *mut nsIAtom; - #[link_name = "\x01?cx@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cx: *mut nsIAtom; - #[link_name = "\x01?cy@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cy: *mut nsIAtom; - #[link_name = "\x01?d@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_d: *mut nsIAtom; - #[link_name = "\x01?darken@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_darken: *mut nsIAtom; - #[link_name = "\x01?defs@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_defs: *mut nsIAtom; - #[link_name = "\x01?deg@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_deg: *mut nsIAtom; - #[link_name = "\x01?desc@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_desc: *mut nsIAtom; - #[link_name = "\x01?diffuseConstant@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_diffuseConstant: *mut nsIAtom; - #[link_name = "\x01?dilate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dilate: *mut nsIAtom; - #[link_name = "\x01?direction@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_direction: *mut nsIAtom; - #[link_name = "\x01?disable@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_disable: *mut nsIAtom; - #[link_name = "\x01?disc@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_disc: *mut nsIAtom; - #[link_name = "\x01?discrete@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_discrete: *mut nsIAtom; - #[link_name = "\x01?divisor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_divisor: *mut nsIAtom; - #[link_name = "\x01?dominant_baseline@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dominant_baseline: *mut nsIAtom; - #[link_name = "\x01?duplicate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_duplicate: *mut nsIAtom; - #[link_name = "\x01?dx@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dx: *mut nsIAtom; - #[link_name = "\x01?dy@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dy: *mut nsIAtom; - #[link_name = "\x01?edgeMode@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_edgeMode: *mut nsIAtom; - #[link_name = "\x01?ellipse@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ellipse: *mut nsIAtom; - #[link_name = "\x01?elevation@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_elevation: *mut nsIAtom; - #[link_name = "\x01?erode@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_erode: *mut nsIAtom; - #[link_name = "\x01?ex@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ex: *mut nsIAtom; - #[link_name = "\x01?exact@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_exact: *mut nsIAtom; - #[link_name = "\x01?exclusion@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_exclusion: *mut nsIAtom; - #[link_name = "\x01?exponent@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_exponent: *mut nsIAtom; - #[link_name = "\x01?feBlend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feBlend: *mut nsIAtom; - #[link_name = "\x01?feColorMatrix@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feColorMatrix: *mut nsIAtom; - #[link_name = "\x01?feComponentTransfer@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feComponentTransfer: *mut nsIAtom; - #[link_name = "\x01?feComposite@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feComposite: *mut nsIAtom; - #[link_name = "\x01?feConvolveMatrix@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feConvolveMatrix: *mut nsIAtom; - #[link_name = "\x01?feDiffuseLighting@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feDiffuseLighting: *mut nsIAtom; - #[link_name = "\x01?feDisplacementMap@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feDisplacementMap: *mut nsIAtom; - #[link_name = "\x01?feDistantLight@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feDistantLight: *mut nsIAtom; - #[link_name = "\x01?feDropShadow@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feDropShadow: *mut nsIAtom; - #[link_name = "\x01?feFlood@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feFlood: *mut nsIAtom; - #[link_name = "\x01?feFuncA@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feFuncA: *mut nsIAtom; - #[link_name = "\x01?feFuncB@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feFuncB: *mut nsIAtom; - #[link_name = "\x01?feFuncG@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feFuncG: *mut nsIAtom; - #[link_name = "\x01?feFuncR@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feFuncR: *mut nsIAtom; - #[link_name = "\x01?feGaussianBlur@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feGaussianBlur: *mut nsIAtom; - #[link_name = "\x01?feImage@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feImage: *mut nsIAtom; - #[link_name = "\x01?feMerge@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feMerge: *mut nsIAtom; - #[link_name = "\x01?feMergeNode@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feMergeNode: *mut nsIAtom; - #[link_name = "\x01?feMorphology@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feMorphology: *mut nsIAtom; - #[link_name = "\x01?feOffset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feOffset: *mut nsIAtom; - #[link_name = "\x01?fePointLight@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fePointLight: *mut nsIAtom; - #[link_name = "\x01?feSpecularLighting@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feSpecularLighting: *mut nsIAtom; - #[link_name = "\x01?feSpotLight@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feSpotLight: *mut nsIAtom; - #[link_name = "\x01?feTile@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feTile: *mut nsIAtom; - #[link_name = "\x01?feTurbulence@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feTurbulence: *mut nsIAtom; - #[link_name = "\x01?fill@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fill: *mut nsIAtom; - #[link_name = "\x01?fill_opacity@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fill_opacity: *mut nsIAtom; - #[link_name = "\x01?fill_rule@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fill_rule: *mut nsIAtom; - #[link_name = "\x01?filter@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_filter: *mut nsIAtom; - #[link_name = "\x01?filterUnits@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_filterUnits: *mut nsIAtom; - #[link_name = "\x01?_float@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__float: *mut nsIAtom; - #[link_name = "\x01?flood_color@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_flood_color: *mut nsIAtom; - #[link_name = "\x01?flood_opacity@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_flood_opacity: *mut nsIAtom; - #[link_name = "\x01?font_face@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_font_face: *mut nsIAtom; - #[link_name = "\x01?font_face_format@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_font_face_format: *mut nsIAtom; - #[link_name = "\x01?font_face_name@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_font_face_name: *mut nsIAtom; - #[link_name = "\x01?font_face_src@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_font_face_src: *mut nsIAtom; - #[link_name = "\x01?font_face_uri@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_font_face_uri: *mut nsIAtom; - #[link_name = "\x01?font_family@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_font_family: *mut nsIAtom; - #[link_name = "\x01?font_size@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_font_size: *mut nsIAtom; - #[link_name = "\x01?font_size_adjust@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_font_size_adjust: *mut nsIAtom; - #[link_name = "\x01?font_stretch@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_font_stretch: *mut nsIAtom; - #[link_name = "\x01?font_style@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_font_style: *mut nsIAtom; - #[link_name = "\x01?font_variant@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_font_variant: *mut nsIAtom; - #[link_name = "\x01?foreignObject@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_foreignObject: *mut nsIAtom; - #[link_name = "\x01?fractalNoise@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fractalNoise: *mut nsIAtom; - #[link_name = "\x01?fr@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fr: *mut nsIAtom; - #[link_name = "\x01?fx@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fx: *mut nsIAtom; - #[link_name = "\x01?fy@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fy: *mut nsIAtom; - #[link_name = "\x01?G@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_G: *mut nsIAtom; - #[link_name = "\x01?g@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_g: *mut nsIAtom; - #[link_name = "\x01?gamma@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_gamma: *mut nsIAtom; - #[link_name = "\x01?generic_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_generic_: *mut nsIAtom; - #[link_name = "\x01?glyphRef@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_glyphRef: *mut nsIAtom; - #[link_name = "\x01?grad@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_grad: *mut nsIAtom; - #[link_name = "\x01?gradientTransform@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_gradientTransform: *mut nsIAtom; - #[link_name = "\x01?gradientUnits@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_gradientUnits: *mut nsIAtom; - #[link_name = "\x01?hardLight@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_hardLight: *mut nsIAtom; - #[link_name = "\x01?hue@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_hue: *mut nsIAtom; - #[link_name = "\x01?hueRotate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_hueRotate: *mut nsIAtom; - #[link_name = "\x01?identity@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_identity: *mut nsIAtom; - #[link_name = "\x01?image_rendering@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_image_rendering: *mut nsIAtom; - #[link_name = "\x01?in@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_in: *mut nsIAtom; - #[link_name = "\x01?in2@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_in2: *mut nsIAtom; - #[link_name = "\x01?intercept@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_intercept: *mut nsIAtom; - #[link_name = "\x01?k1@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_k1: *mut nsIAtom; - #[link_name = "\x01?k2@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_k2: *mut nsIAtom; - #[link_name = "\x01?k3@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_k3: *mut nsIAtom; - #[link_name = "\x01?k4@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_k4: *mut nsIAtom; - #[link_name = "\x01?kernelMatrix@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_kernelMatrix: *mut nsIAtom; - #[link_name = "\x01?kernelUnitLength@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_kernelUnitLength: *mut nsIAtom; - #[link_name = "\x01?lengthAdjust@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lengthAdjust: *mut nsIAtom; - #[link_name = "\x01?letter_spacing@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_letter_spacing: *mut nsIAtom; - #[link_name = "\x01?lighten@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lighten: *mut nsIAtom; - #[link_name = "\x01?lighting_color@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lighting_color: *mut nsIAtom; - #[link_name = "\x01?limitingConeAngle@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_limitingConeAngle: *mut nsIAtom; - #[link_name = "\x01?linear@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_linear: *mut nsIAtom; - #[link_name = "\x01?linearGradient@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_linearGradient: *mut nsIAtom; - #[link_name = "\x01?linearRGB@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_linearRGB: *mut nsIAtom; - #[link_name = "\x01?list_style_type@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_list_style_type: *mut nsIAtom; - #[link_name = "\x01?luminanceToAlpha@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_luminanceToAlpha: *mut nsIAtom; - #[link_name = "\x01?luminosity@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_luminosity: *mut nsIAtom; - #[link_name = "\x01?magnify@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_magnify: *mut nsIAtom; - #[link_name = "\x01?marker@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_marker: *mut nsIAtom; - #[link_name = "\x01?marker_end@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_marker_end: *mut nsIAtom; - #[link_name = "\x01?marker_mid@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_marker_mid: *mut nsIAtom; - #[link_name = "\x01?marker_start@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_marker_start: *mut nsIAtom; - #[link_name = "\x01?markerHeight@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_markerHeight: *mut nsIAtom; - #[link_name = "\x01?markerUnits@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_markerUnits: *mut nsIAtom; - #[link_name = "\x01?markerWidth@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_markerWidth: *mut nsIAtom; - #[link_name = "\x01?mask@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mask: *mut nsIAtom; - #[link_name = "\x01?maskContentUnits@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_maskContentUnits: *mut nsIAtom; - #[link_name = "\x01?mask_type@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mask_type: *mut nsIAtom; - #[link_name = "\x01?maskUnits@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_maskUnits: *mut nsIAtom; - #[link_name = "\x01?matrix@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_matrix: *mut nsIAtom; - #[link_name = "\x01?metadata@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_metadata: *mut nsIAtom; - #[link_name = "\x01?missingGlyph@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_missingGlyph: *mut nsIAtom; - #[link_name = "\x01?mm@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mm: *mut nsIAtom; - #[link_name = "\x01?mpath@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mpath: *mut nsIAtom; - #[link_name = "\x01?noStitch@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_noStitch: *mut nsIAtom; - #[link_name = "\x01?numOctaves@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_numOctaves: *mut nsIAtom; - #[link_name = "\x01?multiply@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_multiply: *mut nsIAtom; - #[link_name = "\x01?objectBoundingBox@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_objectBoundingBox: *mut nsIAtom; - #[link_name = "\x01?offset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_offset: *mut nsIAtom; - #[link_name = "\x01?onSVGLoad@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onSVGLoad: *mut nsIAtom; - #[link_name = "\x01?onSVGResize@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onSVGResize: *mut nsIAtom; - #[link_name = "\x01?onSVGScroll@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onSVGScroll: *mut nsIAtom; - #[link_name = "\x01?onSVGUnload@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onSVGUnload: *mut nsIAtom; - #[link_name = "\x01?onSVGZoom@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onSVGZoom: *mut nsIAtom; - #[link_name = "\x01?onzoom@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onzoom: *mut nsIAtom; - #[link_name = "\x01?opacity@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_opacity: *mut nsIAtom; - #[link_name = "\x01?_operator@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__operator: *mut nsIAtom; - #[link_name = "\x01?out@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_out: *mut nsIAtom; - #[link_name = "\x01?over@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_over: *mut nsIAtom; - #[link_name = "\x01?overridePreserveAspectRatio@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_overridePreserveAspectRatio: *mut nsIAtom; - #[link_name = "\x01?pad@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pad: *mut nsIAtom; - #[link_name = "\x01?path@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_path: *mut nsIAtom; - #[link_name = "\x01?pathLength@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pathLength: *mut nsIAtom; - #[link_name = "\x01?patternContentUnits@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_patternContentUnits: *mut nsIAtom; - #[link_name = "\x01?patternTransform@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_patternTransform: *mut nsIAtom; - #[link_name = "\x01?patternUnits@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_patternUnits: *mut nsIAtom; - #[link_name = "\x01?pc@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pc: *mut nsIAtom; - #[link_name = "\x01?pointer_events@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pointer_events: *mut nsIAtom; - #[link_name = "\x01?points@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_points: *mut nsIAtom; - #[link_name = "\x01?pointsAtX@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pointsAtX: *mut nsIAtom; - #[link_name = "\x01?pointsAtY@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pointsAtY: *mut nsIAtom; - #[link_name = "\x01?pointsAtZ@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pointsAtZ: *mut nsIAtom; - #[link_name = "\x01?polyline@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_polyline: *mut nsIAtom; - #[link_name = "\x01?preserveAlpha@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_preserveAlpha: *mut nsIAtom; - #[link_name = "\x01?preserveAspectRatio@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_preserveAspectRatio: *mut nsIAtom; - #[link_name = "\x01?primitiveUnits@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_primitiveUnits: *mut nsIAtom; - #[link_name = "\x01?pt@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pt: *mut nsIAtom; - #[link_name = "\x01?px@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_px: *mut nsIAtom; - #[link_name = "\x01?R@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_R: *mut nsIAtom; - #[link_name = "\x01?r@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_r: *mut nsIAtom; - #[link_name = "\x01?rad@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rad: *mut nsIAtom; - #[link_name = "\x01?radialGradient@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_radialGradient: *mut nsIAtom; - #[link_name = "\x01?radius@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_radius: *mut nsIAtom; - #[link_name = "\x01?reflect@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_reflect: *mut nsIAtom; - #[link_name = "\x01?refX@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_refX: *mut nsIAtom; - #[link_name = "\x01?refY@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_refY: *mut nsIAtom; - #[link_name = "\x01?requiredExtensions@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_requiredExtensions: *mut nsIAtom; - #[link_name = "\x01?requiredFeatures@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_requiredFeatures: *mut nsIAtom; - #[link_name = "\x01?rotate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rotate: *mut nsIAtom; - #[link_name = "\x01?rx@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rx: *mut nsIAtom; - #[link_name = "\x01?ry@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ry: *mut nsIAtom; - #[link_name = "\x01?saturate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_saturate: *mut nsIAtom; - #[link_name = "\x01?saturation@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_saturation: *mut nsIAtom; - #[link_name = "\x01?set@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_set: *mut nsIAtom; - #[link_name = "\x01?seed@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_seed: *mut nsIAtom; - #[link_name = "\x01?shape_rendering@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_shape_rendering: *mut nsIAtom; - #[link_name = "\x01?skewX@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_skewX: *mut nsIAtom; - #[link_name = "\x01?skewY@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_skewY: *mut nsIAtom; - #[link_name = "\x01?slope@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_slope: *mut nsIAtom; - #[link_name = "\x01?slot@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_slot: *mut nsIAtom; - #[link_name = "\x01?softLight@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_softLight: *mut nsIAtom; - #[link_name = "\x01?spacing@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_spacing: *mut nsIAtom; - #[link_name = "\x01?spacingAndGlyphs@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_spacingAndGlyphs: *mut nsIAtom; - #[link_name = "\x01?specularConstant@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_specularConstant: *mut nsIAtom; - #[link_name = "\x01?specularExponent@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_specularExponent: *mut nsIAtom; - #[link_name = "\x01?spreadMethod@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_spreadMethod: *mut nsIAtom; - #[link_name = "\x01?sRGB@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sRGB: *mut nsIAtom; - #[link_name = "\x01?startOffset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_startOffset: *mut nsIAtom; - #[link_name = "\x01?stdDeviation@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stdDeviation: *mut nsIAtom; - #[link_name = "\x01?stitch@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stitch: *mut nsIAtom; - #[link_name = "\x01?stitchTiles@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stitchTiles: *mut nsIAtom; - #[link_name = "\x01?stop_color@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stop_color: *mut nsIAtom; - #[link_name = "\x01?stop_opacity@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stop_opacity: *mut nsIAtom; - #[link_name = "\x01?stroke@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stroke: *mut nsIAtom; - #[link_name = "\x01?stroke_dasharray@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stroke_dasharray: *mut nsIAtom; - #[link_name = "\x01?stroke_dashoffset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stroke_dashoffset: *mut nsIAtom; - #[link_name = "\x01?stroke_linecap@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stroke_linecap: *mut nsIAtom; - #[link_name = "\x01?stroke_linejoin@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stroke_linejoin: *mut nsIAtom; - #[link_name = "\x01?stroke_miterlimit@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stroke_miterlimit: *mut nsIAtom; - #[link_name = "\x01?stroke_opacity@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stroke_opacity: *mut nsIAtom; - #[link_name = "\x01?stroke_width@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stroke_width: *mut nsIAtom; - #[link_name = "\x01?strokeWidth@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_strokeWidth: *mut nsIAtom; - #[link_name = "\x01?surfaceScale@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_surfaceScale: *mut nsIAtom; - #[link_name = "\x01?svg@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_svg: *mut nsIAtom; - #[link_name = "\x01?svgContextPaint@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_svgContextPaint: *mut nsIAtom; - #[link_name = "\x01?svgSwitch@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_svgSwitch: *mut nsIAtom; - #[link_name = "\x01?symbol@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_symbol: *mut nsIAtom; - #[link_name = "\x01?systemLanguage@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_systemLanguage: *mut nsIAtom; - #[link_name = "\x01?tableValues@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tableValues: *mut nsIAtom; - #[link_name = "\x01?targetX@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_targetX: *mut nsIAtom; - #[link_name = "\x01?targetY@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_targetY: *mut nsIAtom; - #[link_name = "\x01?text_anchor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_text_anchor: *mut nsIAtom; - #[link_name = "\x01?text_rendering@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_text_rendering: *mut nsIAtom; - #[link_name = "\x01?textLength@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_textLength: *mut nsIAtom; - #[link_name = "\x01?textPath@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_textPath: *mut nsIAtom; - #[link_name = "\x01?tref@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tref: *mut nsIAtom; - #[link_name = "\x01?tspan@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tspan: *mut nsIAtom; - #[link_name = "\x01?turbulence@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_turbulence: *mut nsIAtom; - #[link_name = "\x01?unicode_bidi@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_unicode_bidi: *mut nsIAtom; - #[link_name = "\x01?userSpaceOnUse@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_userSpaceOnUse: *mut nsIAtom; - #[link_name = "\x01?view@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_view: *mut nsIAtom; - #[link_name = "\x01?viewBox@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_viewBox: *mut nsIAtom; - #[link_name = "\x01?viewTarget@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_viewTarget: *mut nsIAtom; - #[link_name = "\x01?white_space@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_white_space: *mut nsIAtom; - #[link_name = "\x01?word_spacing@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_word_spacing: *mut nsIAtom; - #[link_name = "\x01?writing_mode@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_writing_mode: *mut nsIAtom; - #[link_name = "\x01?x@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x: *mut nsIAtom; - #[link_name = "\x01?x1@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x1: *mut nsIAtom; - #[link_name = "\x01?x2@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x2: *mut nsIAtom; - #[link_name = "\x01?xChannelSelector@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xChannelSelector: *mut nsIAtom; - #[link_name = "\x01?xor_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xor_: *mut nsIAtom; - #[link_name = "\x01?y@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_y: *mut nsIAtom; - #[link_name = "\x01?y1@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_y1: *mut nsIAtom; - #[link_name = "\x01?y2@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_y2: *mut nsIAtom; - #[link_name = "\x01?yChannelSelector@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_yChannelSelector: *mut nsIAtom; - #[link_name = "\x01?z@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_z: *mut nsIAtom; - #[link_name = "\x01?zoomAndPan@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_zoomAndPan: *mut nsIAtom; - #[link_name = "\x01?vector_effect@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_vector_effect: *mut nsIAtom; - #[link_name = "\x01?vertical_align@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_vertical_align: *mut nsIAtom; - #[link_name = "\x01?accumulate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_accumulate: *mut nsIAtom; - #[link_name = "\x01?additive@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_additive: *mut nsIAtom; - #[link_name = "\x01?attributeName@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_attributeName: *mut nsIAtom; - #[link_name = "\x01?attributeType@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_attributeType: *mut nsIAtom; - #[link_name = "\x01?auto_reverse@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_auto_reverse: *mut nsIAtom; - #[link_name = "\x01?begin@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_begin: *mut nsIAtom; - #[link_name = "\x01?beginEvent@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_beginEvent: *mut nsIAtom; - #[link_name = "\x01?by@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_by: *mut nsIAtom; - #[link_name = "\x01?calcMode@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_calcMode: *mut nsIAtom; - #[link_name = "\x01?css@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_css: *mut nsIAtom; - #[link_name = "\x01?dur@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_dur: *mut nsIAtom; - #[link_name = "\x01?keyPoints@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_keyPoints: *mut nsIAtom; - #[link_name = "\x01?keySplines@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_keySplines: *mut nsIAtom; - #[link_name = "\x01?keyTimes@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_keyTimes: *mut nsIAtom; - #[link_name = "\x01?mozAnimateMotionDummyAttr@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozAnimateMotionDummyAttr: *mut nsIAtom; - #[link_name = "\x01?onbegin@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onbegin: *mut nsIAtom; - #[link_name = "\x01?onbeginEvent@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onbeginEvent: *mut nsIAtom; - #[link_name = "\x01?onend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onend: *mut nsIAtom; - #[link_name = "\x01?onendEvent@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onendEvent: *mut nsIAtom; - #[link_name = "\x01?onrepeat@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onrepeat: *mut nsIAtom; - #[link_name = "\x01?onrepeatEvent@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onrepeatEvent: *mut nsIAtom; - #[link_name = "\x01?repeatCount@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_repeatCount: *mut nsIAtom; - #[link_name = "\x01?repeatDur@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_repeatDur: *mut nsIAtom; - #[link_name = "\x01?repeatEvent@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_repeatEvent: *mut nsIAtom; - #[link_name = "\x01?restart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_restart: *mut nsIAtom; - #[link_name = "\x01?to@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_to: *mut nsIAtom; - #[link_name = "\x01?XML@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_XML: *mut nsIAtom; - #[link_name = "\x01?abs_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_abs_: *mut nsIAtom; - #[link_name = "\x01?accent_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_accent_: *mut nsIAtom; - #[link_name = "\x01?accentunder_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_accentunder_: *mut nsIAtom; - #[link_name = "\x01?actiontype_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_actiontype_: *mut nsIAtom; - #[link_name = "\x01?alignmentscope_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_alignmentscope_: *mut nsIAtom; - #[link_name = "\x01?altimg_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_altimg_: *mut nsIAtom; - #[link_name = "\x01?altimg_height_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_altimg_height_: *mut nsIAtom; - #[link_name = "\x01?altimg_valign_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_altimg_valign_: *mut nsIAtom; - #[link_name = "\x01?altimg_width_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_altimg_width_: *mut nsIAtom; - #[link_name = "\x01?annotation_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_annotation_: *mut nsIAtom; - #[link_name = "\x01?annotation_xml_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_annotation_xml_: *mut nsIAtom; - #[link_name = "\x01?apply_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_apply_: *mut nsIAtom; - #[link_name = "\x01?approx_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_approx_: *mut nsIAtom; - #[link_name = "\x01?arccos_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_arccos_: *mut nsIAtom; - #[link_name = "\x01?arccosh_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_arccosh_: *mut nsIAtom; - #[link_name = "\x01?arccot_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_arccot_: *mut nsIAtom; - #[link_name = "\x01?arccoth_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_arccoth_: *mut nsIAtom; - #[link_name = "\x01?arccsc_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_arccsc_: *mut nsIAtom; - #[link_name = "\x01?arccsch_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_arccsch_: *mut nsIAtom; - #[link_name = "\x01?arcsec_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_arcsec_: *mut nsIAtom; - #[link_name = "\x01?arcsech_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_arcsech_: *mut nsIAtom; - #[link_name = "\x01?arcsin_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_arcsin_: *mut nsIAtom; - #[link_name = "\x01?arcsinh_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_arcsinh_: *mut nsIAtom; - #[link_name = "\x01?arctan_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_arctan_: *mut nsIAtom; - #[link_name = "\x01?arctanh_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_arctanh_: *mut nsIAtom; - #[link_name = "\x01?arg_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_arg_: *mut nsIAtom; - #[link_name = "\x01?bevelled_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_bevelled_: *mut nsIAtom; - #[link_name = "\x01?bind_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_bind_: *mut nsIAtom; - #[link_name = "\x01?bvar_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_bvar_: *mut nsIAtom; - #[link_name = "\x01?card_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_card_: *mut nsIAtom; - #[link_name = "\x01?cartesianproduct_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cartesianproduct_: *mut nsIAtom; - #[link_name = "\x01?cbytes_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cbytes_: *mut nsIAtom; - #[link_name = "\x01?cd_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cd_: *mut nsIAtom; - #[link_name = "\x01?cdgroup_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cdgroup_: *mut nsIAtom; - #[link_name = "\x01?cerror_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cerror_: *mut nsIAtom; - #[link_name = "\x01?charalign_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_charalign_: *mut nsIAtom; - #[link_name = "\x01?ci_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ci_: *mut nsIAtom; - #[link_name = "\x01?closure_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_closure_: *mut nsIAtom; - #[link_name = "\x01?cn_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cn_: *mut nsIAtom; - #[link_name = "\x01?codomain_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_codomain_: *mut nsIAtom; - #[link_name = "\x01?columnalign_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_columnalign_: *mut nsIAtom; - #[link_name = "\x01?columnalignment_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_columnalignment_: *mut nsIAtom; - #[link_name = "\x01?columnlines_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_columnlines_: *mut nsIAtom; - #[link_name = "\x01?columnspacing_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_columnspacing_: *mut nsIAtom; - #[link_name = "\x01?columnspan_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_columnspan_: *mut nsIAtom; - #[link_name = "\x01?columnwidth_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_columnwidth_: *mut nsIAtom; - #[link_name = "\x01?complexes_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_complexes_: *mut nsIAtom; - #[link_name = "\x01?compose_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_compose_: *mut nsIAtom; - #[link_name = "\x01?condition_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_condition_: *mut nsIAtom; - #[link_name = "\x01?conjugate_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_conjugate_: *mut nsIAtom; - #[link_name = "\x01?cos_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cos_: *mut nsIAtom; - #[link_name = "\x01?cosh_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cosh_: *mut nsIAtom; - #[link_name = "\x01?cot_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cot_: *mut nsIAtom; - #[link_name = "\x01?coth_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_coth_: *mut nsIAtom; - #[link_name = "\x01?crossout_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_crossout_: *mut nsIAtom; - #[link_name = "\x01?csc_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_csc_: *mut nsIAtom; - #[link_name = "\x01?csch_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_csch_: *mut nsIAtom; - #[link_name = "\x01?cs_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cs_: *mut nsIAtom; - #[link_name = "\x01?csymbol_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_csymbol_: *mut nsIAtom; - #[link_name = "\x01?curl_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_curl_: *mut nsIAtom; - #[link_name = "\x01?decimalpoint_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_decimalpoint_: *mut nsIAtom; - #[link_name = "\x01?definitionURL_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_definitionURL_: *mut nsIAtom; - #[link_name = "\x01?degree_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_degree_: *mut nsIAtom; - #[link_name = "\x01?denomalign_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_denomalign_: *mut nsIAtom; - #[link_name = "\x01?depth_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_depth_: *mut nsIAtom; - #[link_name = "\x01?determinant_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_determinant_: *mut nsIAtom; - #[link_name = "\x01?diff_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_diff_: *mut nsIAtom; - #[link_name = "\x01?displaystyle_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_displaystyle_: *mut nsIAtom; - #[link_name = "\x01?divergence_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_divergence_: *mut nsIAtom; - #[link_name = "\x01?divide_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_divide_: *mut nsIAtom; - #[link_name = "\x01?domain_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_domain_: *mut nsIAtom; - #[link_name = "\x01?domainofapplication_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_domainofapplication_: *mut nsIAtom; - #[link_name = "\x01?edge_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_edge_: *mut nsIAtom; - #[link_name = "\x01?el_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_el_: *mut nsIAtom; - #[link_name = "\x01?emptyset_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_emptyset_: *mut nsIAtom; - #[link_name = "\x01?eq_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_eq_: *mut nsIAtom; - #[link_name = "\x01?equalcolumns_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_equalcolumns_: *mut nsIAtom; - #[link_name = "\x01?equalrows_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_equalrows_: *mut nsIAtom; - #[link_name = "\x01?equivalent_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_equivalent_: *mut nsIAtom; - #[link_name = "\x01?eulergamma_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_eulergamma_: *mut nsIAtom; - #[link_name = "\x01?exists_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_exists_: *mut nsIAtom; - #[link_name = "\x01?exp_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_exp_: *mut nsIAtom; - #[link_name = "\x01?exponentiale_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_exponentiale_: *mut nsIAtom; - #[link_name = "\x01?factorial_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_factorial_: *mut nsIAtom; - #[link_name = "\x01?factorof_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_factorof_: *mut nsIAtom; - #[link_name = "\x01?fence_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fence_: *mut nsIAtom; - #[link_name = "\x01?fn_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fn_: *mut nsIAtom; - #[link_name = "\x01?fontfamily_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fontfamily_: *mut nsIAtom; - #[link_name = "\x01?fontsize_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fontsize_: *mut nsIAtom; - #[link_name = "\x01?fontstyle_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fontstyle_: *mut nsIAtom; - #[link_name = "\x01?fontweight_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fontweight_: *mut nsIAtom; - #[link_name = "\x01?forall_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_forall_: *mut nsIAtom; - #[link_name = "\x01?framespacing_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_framespacing_: *mut nsIAtom; - #[link_name = "\x01?gcd_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_gcd_: *mut nsIAtom; - #[link_name = "\x01?geq_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_geq_: *mut nsIAtom; - #[link_name = "\x01?groupalign_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_groupalign_: *mut nsIAtom; - #[link_name = "\x01?gt_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_gt_: *mut nsIAtom; - #[link_name = "\x01?ident_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ident_: *mut nsIAtom; - #[link_name = "\x01?imaginaryi_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_imaginaryi_: *mut nsIAtom; - #[link_name = "\x01?imaginary_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_imaginary_: *mut nsIAtom; - #[link_name = "\x01?implies_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_implies_: *mut nsIAtom; - #[link_name = "\x01?indentalignfirst_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_indentalignfirst_: *mut nsIAtom; - #[link_name = "\x01?indentalign_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_indentalign_: *mut nsIAtom; - #[link_name = "\x01?indentalignlast_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_indentalignlast_: *mut nsIAtom; - #[link_name = "\x01?indentshiftfirst_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_indentshiftfirst_: *mut nsIAtom; - #[link_name = "\x01?indentshift_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_indentshift_: *mut nsIAtom; - #[link_name = "\x01?indenttarget_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_indenttarget_: *mut nsIAtom; - #[link_name = "\x01?integers_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_integers_: *mut nsIAtom; - #[link_name = "\x01?intersect_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_intersect_: *mut nsIAtom; - #[link_name = "\x01?interval_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_interval_: *mut nsIAtom; - #[link_name = "\x01?int_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_int_: *mut nsIAtom; - #[link_name = "\x01?inverse_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_inverse_: *mut nsIAtom; - #[link_name = "\x01?lambda_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lambda_: *mut nsIAtom; - #[link_name = "\x01?laplacian_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_laplacian_: *mut nsIAtom; - #[link_name = "\x01?largeop_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_largeop_: *mut nsIAtom; - #[link_name = "\x01?lcm_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lcm_: *mut nsIAtom; - #[link_name = "\x01?leq_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_leq_: *mut nsIAtom; - #[link_name = "\x01?limit_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_limit_: *mut nsIAtom; - #[link_name = "\x01?linebreak_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_linebreak_: *mut nsIAtom; - #[link_name = "\x01?linebreakmultchar_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_linebreakmultchar_: *mut nsIAtom; - #[link_name = "\x01?linebreakstyle_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_linebreakstyle_: *mut nsIAtom; - #[link_name = "\x01?linethickness_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_linethickness_: *mut nsIAtom; - #[link_name = "\x01?list_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_list_: *mut nsIAtom; - #[link_name = "\x01?ln_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ln_: *mut nsIAtom; - #[link_name = "\x01?location_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_location_: *mut nsIAtom; - #[link_name = "\x01?logbase_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_logbase_: *mut nsIAtom; - #[link_name = "\x01?log_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_log_: *mut nsIAtom; - #[link_name = "\x01?longdivstyle_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_longdivstyle_: *mut nsIAtom; - #[link_name = "\x01?lowlimit_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lowlimit_: *mut nsIAtom; - #[link_name = "\x01?lquote_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lquote_: *mut nsIAtom; - #[link_name = "\x01?lspace_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lspace_: *mut nsIAtom; - #[link_name = "\x01?lt_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lt_: *mut nsIAtom; - #[link_name = "\x01?maction_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_maction_: *mut nsIAtom; - #[link_name = "\x01?maligngroup_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_maligngroup_: *mut nsIAtom; - #[link_name = "\x01?malignmark_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_malignmark_: *mut nsIAtom; - #[link_name = "\x01?mathbackground_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mathbackground_: *mut nsIAtom; - #[link_name = "\x01?mathcolor_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mathcolor_: *mut nsIAtom; - #[link_name = "\x01?mathsize_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mathsize_: *mut nsIAtom; - #[link_name = "\x01?mathvariant_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mathvariant_: *mut nsIAtom; - #[link_name = "\x01?matrixrow_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_matrixrow_: *mut nsIAtom; - #[link_name = "\x01?maxsize_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_maxsize_: *mut nsIAtom; - #[link_name = "\x01?mean_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mean_: *mut nsIAtom; - #[link_name = "\x01?median_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_median_: *mut nsIAtom; - #[link_name = "\x01?menclose_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_menclose_: *mut nsIAtom; - #[link_name = "\x01?merror_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_merror_: *mut nsIAtom; - #[link_name = "\x01?mfenced_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mfenced_: *mut nsIAtom; - #[link_name = "\x01?mfrac_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mfrac_: *mut nsIAtom; - #[link_name = "\x01?mglyph_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mglyph_: *mut nsIAtom; - #[link_name = "\x01?mi_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mi_: *mut nsIAtom; - #[link_name = "\x01?minlabelspacing_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_minlabelspacing_: *mut nsIAtom; - #[link_name = "\x01?minsize_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_minsize_: *mut nsIAtom; - #[link_name = "\x01?minus_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_minus_: *mut nsIAtom; - #[link_name = "\x01?mlabeledtr_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mlabeledtr_: *mut nsIAtom; - #[link_name = "\x01?mlongdiv_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mlongdiv_: *mut nsIAtom; - #[link_name = "\x01?mmultiscripts_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mmultiscripts_: *mut nsIAtom; - #[link_name = "\x01?mn_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mn_: *mut nsIAtom; - #[link_name = "\x01?momentabout_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_momentabout_: *mut nsIAtom; - #[link_name = "\x01?moment_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_moment_: *mut nsIAtom; - #[link_name = "\x01?mo_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mo_: *mut nsIAtom; - #[link_name = "\x01?movablelimits_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_movablelimits_: *mut nsIAtom; - #[link_name = "\x01?mover_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mover_: *mut nsIAtom; - #[link_name = "\x01?mpadded_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mpadded_: *mut nsIAtom; - #[link_name = "\x01?mphantom_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mphantom_: *mut nsIAtom; - #[link_name = "\x01?mprescripts_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mprescripts_: *mut nsIAtom; - #[link_name = "\x01?mroot_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mroot_: *mut nsIAtom; - #[link_name = "\x01?mrow_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mrow_: *mut nsIAtom; - #[link_name = "\x01?mscarries_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mscarries_: *mut nsIAtom; - #[link_name = "\x01?mscarry_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mscarry_: *mut nsIAtom; - #[link_name = "\x01?msgroup_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_msgroup_: *mut nsIAtom; - #[link_name = "\x01?msline_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_msline_: *mut nsIAtom; - #[link_name = "\x01?ms_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ms_: *mut nsIAtom; - #[link_name = "\x01?mspace_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mspace_: *mut nsIAtom; - #[link_name = "\x01?msqrt_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_msqrt_: *mut nsIAtom; - #[link_name = "\x01?msrow_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_msrow_: *mut nsIAtom; - #[link_name = "\x01?mstack_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mstack_: *mut nsIAtom; - #[link_name = "\x01?mstyle_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mstyle_: *mut nsIAtom; - #[link_name = "\x01?msub_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_msub_: *mut nsIAtom; - #[link_name = "\x01?msubsup_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_msubsup_: *mut nsIAtom; - #[link_name = "\x01?msup_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_msup_: *mut nsIAtom; - #[link_name = "\x01?mtable_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mtable_: *mut nsIAtom; - #[link_name = "\x01?mtd_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mtd_: *mut nsIAtom; - #[link_name = "\x01?mtext_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mtext_: *mut nsIAtom; - #[link_name = "\x01?mtr_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mtr_: *mut nsIAtom; - #[link_name = "\x01?munder_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_munder_: *mut nsIAtom; - #[link_name = "\x01?munderover_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_munderover_: *mut nsIAtom; - #[link_name = "\x01?naturalnumbers_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_naturalnumbers_: *mut nsIAtom; - #[link_name = "\x01?neq_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_neq_: *mut nsIAtom; - #[link_name = "\x01?notanumber_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_notanumber_: *mut nsIAtom; - #[link_name = "\x01?notation_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_notation_: *mut nsIAtom; - #[link_name = "\x01?note_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_note_: *mut nsIAtom; - #[link_name = "\x01?notin_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_notin_: *mut nsIAtom; - #[link_name = "\x01?notprsubset_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_notprsubset_: *mut nsIAtom; - #[link_name = "\x01?notsubset_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_notsubset_: *mut nsIAtom; - #[link_name = "\x01?numalign_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_numalign_: *mut nsIAtom; - #[link_name = "\x01?other_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_other_: *mut nsIAtom; - #[link_name = "\x01?outerproduct_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_outerproduct_: *mut nsIAtom; - #[link_name = "\x01?partialdiff_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_partialdiff_: *mut nsIAtom; - #[link_name = "\x01?piece_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_piece_: *mut nsIAtom; - #[link_name = "\x01?piecewise_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_piecewise_: *mut nsIAtom; - #[link_name = "\x01?pi_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pi_: *mut nsIAtom; - #[link_name = "\x01?plus_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_plus_: *mut nsIAtom; - #[link_name = "\x01?power_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_power_: *mut nsIAtom; - #[link_name = "\x01?primes_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_primes_: *mut nsIAtom; - #[link_name = "\x01?product_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_product_: *mut nsIAtom; - #[link_name = "\x01?prsubset_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_prsubset_: *mut nsIAtom; - #[link_name = "\x01?quotient_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_quotient_: *mut nsIAtom; - #[link_name = "\x01?rationals_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rationals_: *mut nsIAtom; - #[link_name = "\x01?real_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_real_: *mut nsIAtom; - #[link_name = "\x01?reals_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_reals_: *mut nsIAtom; - #[link_name = "\x01?reln_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_reln_: *mut nsIAtom; - #[link_name = "\x01?root_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_root_: *mut nsIAtom; - #[link_name = "\x01?rowalign_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rowalign_: *mut nsIAtom; - #[link_name = "\x01?rowlines_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rowlines_: *mut nsIAtom; - #[link_name = "\x01?rowspacing_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rowspacing_: *mut nsIAtom; - #[link_name = "\x01?rquote_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rquote_: *mut nsIAtom; - #[link_name = "\x01?rspace_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rspace_: *mut nsIAtom; - #[link_name = "\x01?scalarproduct_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scalarproduct_: *mut nsIAtom; - #[link_name = "\x01?schemaLocation_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_schemaLocation_: *mut nsIAtom; - #[link_name = "\x01?scriptlevel_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scriptlevel_: *mut nsIAtom; - #[link_name = "\x01?scriptminsize_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scriptminsize_: *mut nsIAtom; - #[link_name = "\x01?scriptsizemultiplier_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scriptsizemultiplier_: *mut nsIAtom; - #[link_name = "\x01?scriptsize_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scriptsize_: *mut nsIAtom; - #[link_name = "\x01?sdev_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sdev_: *mut nsIAtom; - #[link_name = "\x01?sech_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sech_: *mut nsIAtom; - #[link_name = "\x01?sec_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sec_: *mut nsIAtom; - #[link_name = "\x01?selection_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_selection_: *mut nsIAtom; - #[link_name = "\x01?selector_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_selector_: *mut nsIAtom; - #[link_name = "\x01?semantics_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_semantics_: *mut nsIAtom; - #[link_name = "\x01?separator_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_separator_: *mut nsIAtom; - #[link_name = "\x01?separators_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_separators_: *mut nsIAtom; - #[link_name = "\x01?sep_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sep_: *mut nsIAtom; - #[link_name = "\x01?setdiff_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_setdiff_: *mut nsIAtom; - #[link_name = "\x01?set_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_set_: *mut nsIAtom; - #[link_name = "\x01?share_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_share_: *mut nsIAtom; - #[link_name = "\x01?shift_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_shift_: *mut nsIAtom; - #[link_name = "\x01?side_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_side_: *mut nsIAtom; - #[link_name = "\x01?sinh_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sinh_: *mut nsIAtom; - #[link_name = "\x01?sin_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sin_: *mut nsIAtom; - #[link_name = "\x01?stackalign_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stackalign_: *mut nsIAtom; - #[link_name = "\x01?stretchy_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stretchy_: *mut nsIAtom; - #[link_name = "\x01?subscriptshift_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_subscriptshift_: *mut nsIAtom; - #[link_name = "\x01?subset_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_subset_: *mut nsIAtom; - #[link_name = "\x01?superscriptshift_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_superscriptshift_: *mut nsIAtom; - #[link_name = "\x01?symmetric_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_symmetric_: *mut nsIAtom; - #[link_name = "\x01?tanh_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tanh_: *mut nsIAtom; - #[link_name = "\x01?tan_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tan_: *mut nsIAtom; - #[link_name = "\x01?tendsto_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tendsto_: *mut nsIAtom; - #[link_name = "\x01?times_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_times_: *mut nsIAtom; - #[link_name = "\x01?transpose_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_transpose_: *mut nsIAtom; - #[link_name = "\x01?union_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_union_: *mut nsIAtom; - #[link_name = "\x01?uplimit_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_uplimit_: *mut nsIAtom; - #[link_name = "\x01?variance_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_variance_: *mut nsIAtom; - #[link_name = "\x01?vectorproduct_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_vectorproduct_: *mut nsIAtom; - #[link_name = "\x01?vector_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_vector_: *mut nsIAtom; - #[link_name = "\x01?voffset_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_voffset_: *mut nsIAtom; - #[link_name = "\x01?xref_@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xref_: *mut nsIAtom; - #[link_name = "\x01?math@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_math: *mut nsIAtom; - #[link_name = "\x01?avg@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_avg: *mut nsIAtom; - #[link_name = "\x01?booleanFromString@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_booleanFromString: *mut nsIAtom; - #[link_name = "\x01?countNonEmpty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_countNonEmpty: *mut nsIAtom; - #[link_name = "\x01?daysFromDate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_daysFromDate: *mut nsIAtom; - #[link_name = "\x01?init@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_init: *mut nsIAtom; - #[link_name = "\x01?instance@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_instance: *mut nsIAtom; - #[link_name = "\x01?months@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_months: *mut nsIAtom; - #[link_name = "\x01?now@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_now: *mut nsIAtom; - #[link_name = "\x01?seconds@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_seconds: *mut nsIAtom; - #[link_name = "\x01?secondsFromDateTime@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_secondsFromDateTime: *mut nsIAtom; - #[link_name = "\x01?onMozSwipeGestureMayStart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onMozSwipeGestureMayStart: *mut nsIAtom; - #[link_name = "\x01?onMozSwipeGestureStart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onMozSwipeGestureStart: *mut nsIAtom; - #[link_name = "\x01?onMozSwipeGestureUpdate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onMozSwipeGestureUpdate: *mut nsIAtom; - #[link_name = "\x01?onMozSwipeGestureEnd@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onMozSwipeGestureEnd: *mut nsIAtom; - #[link_name = "\x01?onMozSwipeGesture@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onMozSwipeGesture: *mut nsIAtom; - #[link_name = "\x01?onMozMagnifyGestureStart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onMozMagnifyGestureStart: *mut nsIAtom; - #[link_name = "\x01?onMozMagnifyGestureUpdate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onMozMagnifyGestureUpdate: *mut nsIAtom; - #[link_name = "\x01?onMozMagnifyGesture@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onMozMagnifyGesture: *mut nsIAtom; - #[link_name = "\x01?onMozRotateGestureStart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onMozRotateGestureStart: *mut nsIAtom; - #[link_name = "\x01?onMozRotateGestureUpdate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onMozRotateGestureUpdate: *mut nsIAtom; - #[link_name = "\x01?onMozRotateGesture@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onMozRotateGesture: *mut nsIAtom; - #[link_name = "\x01?onMozTapGesture@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onMozTapGesture: *mut nsIAtom; - #[link_name = "\x01?onMozPressTapGesture@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onMozPressTapGesture: *mut nsIAtom; - #[link_name = "\x01?onMozEdgeUIStarted@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onMozEdgeUIStarted: *mut nsIAtom; - #[link_name = "\x01?onMozEdgeUICanceled@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onMozEdgeUICanceled: *mut nsIAtom; - #[link_name = "\x01?onMozEdgeUICompleted@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onMozEdgeUICompleted: *mut nsIAtom; - #[link_name = "\x01?onpointerdown@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpointerdown: *mut nsIAtom; - #[link_name = "\x01?onpointermove@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpointermove: *mut nsIAtom; - #[link_name = "\x01?onpointerup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpointerup: *mut nsIAtom; - #[link_name = "\x01?onpointercancel@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpointercancel: *mut nsIAtom; - #[link_name = "\x01?onpointerover@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpointerover: *mut nsIAtom; - #[link_name = "\x01?onpointerout@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpointerout: *mut nsIAtom; - #[link_name = "\x01?onpointerenter@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpointerenter: *mut nsIAtom; - #[link_name = "\x01?onpointerleave@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpointerleave: *mut nsIAtom; - #[link_name = "\x01?ongotpointercapture@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ongotpointercapture: *mut nsIAtom; - #[link_name = "\x01?onlostpointercapture@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onlostpointercapture: *mut nsIAtom; - #[link_name = "\x01?ondevicemotion@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondevicemotion: *mut nsIAtom; - #[link_name = "\x01?ondeviceorientation@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondeviceorientation: *mut nsIAtom; - #[link_name = "\x01?onabsolutedeviceorientation@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onabsolutedeviceorientation: *mut nsIAtom; - #[link_name = "\x01?ondeviceproximity@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondeviceproximity: *mut nsIAtom; - #[link_name = "\x01?onmozorientationchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmozorientationchange: *mut nsIAtom; - #[link_name = "\x01?onuserproximity@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onuserproximity: *mut nsIAtom; - #[link_name = "\x01?ondevicelight@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondevicelight: *mut nsIAtom; - #[link_name = "\x01?ondevicechange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondevicechange: *mut nsIAtom; - #[link_name = "\x01?mozinputrangeignorepreventdefault@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozinputrangeignorepreventdefault: *mut nsIAtom; - #[link_name = "\x01?moz_extension@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_moz_extension: *mut nsIAtom; - #[link_name = "\x01?all_urlsPermission@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_all_urlsPermission: *mut nsIAtom; - #[link_name = "\x01?clipboardRead@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_clipboardRead: *mut nsIAtom; - #[link_name = "\x01?clipboardWrite@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_clipboardWrite: *mut nsIAtom; - #[link_name = "\x01?debugger@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_debugger: *mut nsIAtom; - #[link_name = "\x01?tabs@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tabs: *mut nsIAtom; - #[link_name = "\x01?webRequestBlocking@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_webRequestBlocking: *mut nsIAtom; - #[link_name = "\x01?http@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_http: *mut nsIAtom; - #[link_name = "\x01?https@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_https: *mut nsIAtom; - #[link_name = "\x01?proxy@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_proxy: *mut nsIAtom; - #[link_name = "\x01?cdataTagName@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cdataTagName: *mut nsIAtom; - #[link_name = "\x01?commentTagName@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_commentTagName: *mut nsIAtom; - #[link_name = "\x01?documentNodeName@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_documentNodeName: *mut nsIAtom; - #[link_name = "\x01?documentFragmentNodeName@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_documentFragmentNodeName: *mut nsIAtom; - #[link_name = "\x01?documentTypeNodeName@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_documentTypeNodeName: *mut nsIAtom; - #[link_name = "\x01?processingInstructionTagName@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_processingInstructionTagName: *mut nsIAtom; - #[link_name = "\x01?textTagName@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_textTagName: *mut nsIAtom; - #[link_name = "\x01?placeholderFrame@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_placeholderFrame: *mut nsIAtom; - #[link_name = "\x01?onloadend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onloadend: *mut nsIAtom; - #[link_name = "\x01?onloadstart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onloadstart: *mut nsIAtom; - #[link_name = "\x01?onprogress@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onprogress: *mut nsIAtom; - #[link_name = "\x01?onsuspend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onsuspend: *mut nsIAtom; - #[link_name = "\x01?onemptied@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onemptied: *mut nsIAtom; - #[link_name = "\x01?onstalled@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onstalled: *mut nsIAtom; - #[link_name = "\x01?onplay@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onplay: *mut nsIAtom; - #[link_name = "\x01?onpause@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onpause: *mut nsIAtom; - #[link_name = "\x01?onloadedmetadata@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onloadedmetadata: *mut nsIAtom; - #[link_name = "\x01?onloadeddata@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onloadeddata: *mut nsIAtom; - #[link_name = "\x01?onwaiting@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onwaiting: *mut nsIAtom; - #[link_name = "\x01?onplaying@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onplaying: *mut nsIAtom; - #[link_name = "\x01?oncanplay@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncanplay: *mut nsIAtom; - #[link_name = "\x01?oncanplaythrough@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncanplaythrough: *mut nsIAtom; - #[link_name = "\x01?onseeking@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onseeking: *mut nsIAtom; - #[link_name = "\x01?onseeked@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onseeked: *mut nsIAtom; - #[link_name = "\x01?ontimeout@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ontimeout: *mut nsIAtom; - #[link_name = "\x01?ontimeupdate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ontimeupdate: *mut nsIAtom; - #[link_name = "\x01?onended@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onended: *mut nsIAtom; - #[link_name = "\x01?onratechange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onratechange: *mut nsIAtom; - #[link_name = "\x01?ondurationchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondurationchange: *mut nsIAtom; - #[link_name = "\x01?onvolumechange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onvolumechange: *mut nsIAtom; - #[link_name = "\x01?onaddtrack@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onaddtrack: *mut nsIAtom; - #[link_name = "\x01?oncontrollerchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncontrollerchange: *mut nsIAtom; - #[link_name = "\x01?oncuechange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_oncuechange: *mut nsIAtom; - #[link_name = "\x01?onenter@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onenter: *mut nsIAtom; - #[link_name = "\x01?onexit@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onexit: *mut nsIAtom; - #[link_name = "\x01?onencrypted@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onencrypted: *mut nsIAtom; - #[link_name = "\x01?encrypted@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_encrypted: *mut nsIAtom; - #[link_name = "\x01?onwaitingforkey@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onwaitingforkey: *mut nsIAtom; - #[link_name = "\x01?onkeystatuseschange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onkeystatuseschange: *mut nsIAtom; - #[link_name = "\x01?onremovetrack@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onremovetrack: *mut nsIAtom; - #[link_name = "\x01?loadstart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_loadstart: *mut nsIAtom; - #[link_name = "\x01?suspend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_suspend: *mut nsIAtom; - #[link_name = "\x01?emptied@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_emptied: *mut nsIAtom; - #[link_name = "\x01?stalled@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stalled: *mut nsIAtom; - #[link_name = "\x01?play@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_play: *mut nsIAtom; - #[link_name = "\x01?pause@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pause: *mut nsIAtom; - #[link_name = "\x01?loadedmetadata@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_loadedmetadata: *mut nsIAtom; - #[link_name = "\x01?loadeddata@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_loadeddata: *mut nsIAtom; - #[link_name = "\x01?waiting@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_waiting: *mut nsIAtom; - #[link_name = "\x01?playing@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_playing: *mut nsIAtom; - #[link_name = "\x01?seeking@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_seeking: *mut nsIAtom; - #[link_name = "\x01?seeked@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_seeked: *mut nsIAtom; - #[link_name = "\x01?timeupdate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_timeupdate: *mut nsIAtom; - #[link_name = "\x01?ended@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ended: *mut nsIAtom; - #[link_name = "\x01?canplay@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_canplay: *mut nsIAtom; - #[link_name = "\x01?canplaythrough@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_canplaythrough: *mut nsIAtom; - #[link_name = "\x01?ratechange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ratechange: *mut nsIAtom; - #[link_name = "\x01?durationchange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_durationchange: *mut nsIAtom; - #[link_name = "\x01?volumechange@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_volumechange: *mut nsIAtom; - #[link_name = "\x01?ondataavailable@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ondataavailable: *mut nsIAtom; - #[link_name = "\x01?onwarning@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onwarning: *mut nsIAtom; - #[link_name = "\x01?onstart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onstart: *mut nsIAtom; - #[link_name = "\x01?onstop@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onstop: *mut nsIAtom; - #[link_name = "\x01?onphoto@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onphoto: *mut nsIAtom; - #[link_name = "\x01?onactivestatechanged@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onactivestatechanged: *mut nsIAtom; - #[link_name = "\x01?ongamepadbuttondown@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ongamepadbuttondown: *mut nsIAtom; - #[link_name = "\x01?ongamepadbuttonup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ongamepadbuttonup: *mut nsIAtom; - #[link_name = "\x01?ongamepadaxismove@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ongamepadaxismove: *mut nsIAtom; - #[link_name = "\x01?ongamepadconnected@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ongamepadconnected: *mut nsIAtom; - #[link_name = "\x01?ongamepaddisconnected@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ongamepaddisconnected: *mut nsIAtom; - #[link_name = "\x01?afterPseudoProperty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_afterPseudoProperty: *mut nsIAtom; - #[link_name = "\x01?animationsProperty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_animationsProperty: *mut nsIAtom; - #[link_name = "\x01?animationsOfBeforeProperty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_animationsOfBeforeProperty: *mut nsIAtom; - #[link_name = "\x01?animationsOfAfterProperty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_animationsOfAfterProperty: *mut nsIAtom; - #[link_name = "\x01?animationEffectsProperty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_animationEffectsProperty: *mut nsIAtom; - #[link_name = "\x01?animationEffectsForBeforeProperty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_animationEffectsForBeforeProperty: *mut nsIAtom; - #[link_name = "\x01?animationEffectsForAfterProperty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_animationEffectsForAfterProperty: *mut nsIAtom; - #[link_name = "\x01?beforePseudoProperty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_beforePseudoProperty: *mut nsIAtom; - #[link_name = "\x01?cssPseudoElementBeforeProperty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cssPseudoElementBeforeProperty: *mut nsIAtom; - #[link_name = "\x01?cssPseudoElementAfterProperty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cssPseudoElementAfterProperty: *mut nsIAtom; - #[link_name = "\x01?transitionsProperty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_transitionsProperty: *mut nsIAtom; - #[link_name = "\x01?transitionsOfBeforeProperty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_transitionsOfBeforeProperty: *mut nsIAtom; - #[link_name = "\x01?transitionsOfAfterProperty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_transitionsOfAfterProperty: *mut nsIAtom; - #[link_name = "\x01?genConInitializerProperty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_genConInitializerProperty: *mut nsIAtom; - #[link_name = "\x01?labelMouseDownPtProperty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_labelMouseDownPtProperty: *mut nsIAtom; - #[link_name = "\x01?lockedStyleStates@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lockedStyleStates: *mut nsIAtom; - #[link_name = "\x01?apzCallbackTransform@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_apzCallbackTransform: *mut nsIAtom; - #[link_name = "\x01?restylableAnonymousNode@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_restylableAnonymousNode: *mut nsIAtom; - #[link_name = "\x01?paintRequestTime@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_paintRequestTime: *mut nsIAtom; - #[link_name = "\x01?pseudoProperty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pseudoProperty: *mut nsIAtom; - #[link_name = "\x01?manualNACProperty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_manualNACProperty: *mut nsIAtom; - #[link_name = "\x01?Japanese@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_Japanese: *mut nsIAtom; - #[link_name = "\x01?Chinese@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_Chinese: *mut nsIAtom; - #[link_name = "\x01?Taiwanese@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_Taiwanese: *mut nsIAtom; - #[link_name = "\x01?HongKongChinese@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_HongKongChinese: *mut nsIAtom; - #[link_name = "\x01?Unicode@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_Unicode: *mut nsIAtom; - #[link_name = "\x01?ko@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ko: *mut nsIAtom; - #[link_name = "\x01?zh_cn@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_zh_cn: *mut nsIAtom; - #[link_name = "\x01?zh_hk@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_zh_hk: *mut nsIAtom; - #[link_name = "\x01?zh_tw@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_zh_tw: *mut nsIAtom; - #[link_name = "\x01?x_cyrillic@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x_cyrillic: *mut nsIAtom; - #[link_name = "\x01?he@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_he: *mut nsIAtom; - #[link_name = "\x01?ar@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ar: *mut nsIAtom; - #[link_name = "\x01?x_devanagari@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x_devanagari: *mut nsIAtom; - #[link_name = "\x01?x_tamil@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x_tamil: *mut nsIAtom; - #[link_name = "\x01?x_armn@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x_armn: *mut nsIAtom; - #[link_name = "\x01?x_beng@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x_beng: *mut nsIAtom; - #[link_name = "\x01?x_cans@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x_cans: *mut nsIAtom; - #[link_name = "\x01?x_ethi@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x_ethi: *mut nsIAtom; - #[link_name = "\x01?x_geor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x_geor: *mut nsIAtom; - #[link_name = "\x01?x_gujr@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x_gujr: *mut nsIAtom; - #[link_name = "\x01?x_guru@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x_guru: *mut nsIAtom; - #[link_name = "\x01?x_khmr@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x_khmr: *mut nsIAtom; - #[link_name = "\x01?x_knda@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x_knda: *mut nsIAtom; - #[link_name = "\x01?x_mlym@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x_mlym: *mut nsIAtom; - #[link_name = "\x01?x_orya@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x_orya: *mut nsIAtom; - #[link_name = "\x01?x_sinh@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x_sinh: *mut nsIAtom; - #[link_name = "\x01?x_telu@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x_telu: *mut nsIAtom; - #[link_name = "\x01?x_tibt@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x_tibt: *mut nsIAtom; - #[link_name = "\x01?az@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_az: *mut nsIAtom; - #[link_name = "\x01?ba@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ba: *mut nsIAtom; - #[link_name = "\x01?crh@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_crh: *mut nsIAtom; - #[link_name = "\x01?el@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_el: *mut nsIAtom; - #[link_name = "\x01?ga@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ga: *mut nsIAtom; - #[link_name = "\x01?nl@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nl: *mut nsIAtom; - #[link_name = "\x01?x_math@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_x_math: *mut nsIAtom; - #[link_name = "\x01?TypingTxnName@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_TypingTxnName: *mut nsIAtom; - #[link_name = "\x01?IMETxnName@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_IMETxnName: *mut nsIAtom; - #[link_name = "\x01?DeleteTxnName@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_DeleteTxnName: *mut nsIAtom; - #[link_name = "\x01?serif@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_serif: *mut nsIAtom; - #[link_name = "\x01?sans_serif@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_sans_serif: *mut nsIAtom; - #[link_name = "\x01?cursive@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cursive: *mut nsIAtom; - #[link_name = "\x01?fantasy@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fantasy: *mut nsIAtom; - #[link_name = "\x01?monospace@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_monospace: *mut nsIAtom; - #[link_name = "\x01?mozfixed@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mozfixed: *mut nsIAtom; - #[link_name = "\x01?Remote@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_Remote: *mut nsIAtom; - #[link_name = "\x01?RemoteId@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_RemoteId: *mut nsIAtom; - #[link_name = "\x01?RemoteType@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_RemoteType: *mut nsIAtom; - #[link_name = "\x01?DisplayPort@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_DisplayPort: *mut nsIAtom; - #[link_name = "\x01?DisplayPortMargins@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_DisplayPortMargins: *mut nsIAtom; - #[link_name = "\x01?DisplayPortBase@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_DisplayPortBase: *mut nsIAtom; - #[link_name = "\x01?AsyncScrollLayerCreationFailed@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_AsyncScrollLayerCreationFailed: *mut nsIAtom; - #[link_name = "\x01?forcemessagemanager@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_forcemessagemanager: *mut nsIAtom; - #[link_name = "\x01?isPreloadBrowser@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_isPreloadBrowser: *mut nsIAtom; - #[link_name = "\x01?color_picker_available@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_color_picker_available: *mut nsIAtom; - #[link_name = "\x01?scrollbar_start_backward@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scrollbar_start_backward: *mut nsIAtom; - #[link_name = "\x01?scrollbar_start_forward@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scrollbar_start_forward: *mut nsIAtom; - #[link_name = "\x01?scrollbar_end_backward@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scrollbar_end_backward: *mut nsIAtom; - #[link_name = "\x01?scrollbar_end_forward@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scrollbar_end_forward: *mut nsIAtom; - #[link_name = "\x01?scrollbar_thumb_proportional@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scrollbar_thumb_proportional: *mut nsIAtom; - #[link_name = "\x01?overlay_scrollbars@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_overlay_scrollbars: *mut nsIAtom; - #[link_name = "\x01?windows_accent_color_in_titlebar@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_windows_accent_color_in_titlebar: *mut nsIAtom; - #[link_name = "\x01?windows_default_theme@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_windows_default_theme: *mut nsIAtom; - #[link_name = "\x01?mac_graphite_theme@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mac_graphite_theme: *mut nsIAtom; - #[link_name = "\x01?mac_yosemite_theme@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mac_yosemite_theme: *mut nsIAtom; - #[link_name = "\x01?windows_compositor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_windows_compositor: *mut nsIAtom; - #[link_name = "\x01?windows_glass@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_windows_glass: *mut nsIAtom; - #[link_name = "\x01?touch_enabled@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_touch_enabled: *mut nsIAtom; - #[link_name = "\x01?menubar_drag@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_menubar_drag: *mut nsIAtom; - #[link_name = "\x01?swipe_animation_enabled@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_swipe_animation_enabled: *mut nsIAtom; - #[link_name = "\x01?physical_home_button@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_physical_home_button: *mut nsIAtom; - #[link_name = "\x01?windows_classic@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_windows_classic: *mut nsIAtom; - #[link_name = "\x01?windows_theme_aero@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_windows_theme_aero: *mut nsIAtom; - #[link_name = "\x01?windows_theme_aero_lite@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_windows_theme_aero_lite: *mut nsIAtom; - #[link_name = "\x01?windows_theme_luna_blue@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_windows_theme_luna_blue: *mut nsIAtom; - #[link_name = "\x01?windows_theme_luna_olive@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_windows_theme_luna_olive: *mut nsIAtom; - #[link_name = "\x01?windows_theme_luna_silver@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_windows_theme_luna_silver: *mut nsIAtom; - #[link_name = "\x01?windows_theme_royale@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_windows_theme_royale: *mut nsIAtom; - #[link_name = "\x01?windows_theme_zune@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_windows_theme_zune: *mut nsIAtom; - #[link_name = "\x01?windows_theme_generic@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_windows_theme_generic: *mut nsIAtom; - #[link_name = "\x01?_moz_color_picker_available@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_color_picker_available: *mut nsIAtom; - #[link_name = "\x01?_moz_scrollbar_start_backward@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_scrollbar_start_backward: *mut nsIAtom; - #[link_name = "\x01?_moz_scrollbar_start_forward@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_scrollbar_start_forward: *mut nsIAtom; - #[link_name = "\x01?_moz_scrollbar_end_backward@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_scrollbar_end_backward: *mut nsIAtom; - #[link_name = "\x01?_moz_scrollbar_end_forward@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_scrollbar_end_forward: *mut nsIAtom; - #[link_name = "\x01?_moz_scrollbar_thumb_proportional@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_scrollbar_thumb_proportional: *mut nsIAtom; - #[link_name = "\x01?_moz_overlay_scrollbars@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_overlay_scrollbars: *mut nsIAtom; - #[link_name = "\x01?_moz_windows_accent_color_in_titlebar@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_windows_accent_color_in_titlebar: *mut nsIAtom; - #[link_name = "\x01?_moz_windows_default_theme@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_windows_default_theme: *mut nsIAtom; - #[link_name = "\x01?_moz_mac_graphite_theme@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_mac_graphite_theme: *mut nsIAtom; - #[link_name = "\x01?_moz_mac_yosemite_theme@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_mac_yosemite_theme: *mut nsIAtom; - #[link_name = "\x01?_moz_windows_compositor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_windows_compositor: *mut nsIAtom; - #[link_name = "\x01?_moz_windows_classic@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_windows_classic: *mut nsIAtom; - #[link_name = "\x01?_moz_windows_glass@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_windows_glass: *mut nsIAtom; - #[link_name = "\x01?_moz_windows_theme@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_windows_theme: *mut nsIAtom; - #[link_name = "\x01?_moz_os_version@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_os_version: *mut nsIAtom; - #[link_name = "\x01?_moz_touch_enabled@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_touch_enabled: *mut nsIAtom; - #[link_name = "\x01?_moz_menubar_drag@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_menubar_drag: *mut nsIAtom; - #[link_name = "\x01?_moz_device_pixel_ratio@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_device_pixel_ratio: *mut nsIAtom; - #[link_name = "\x01?_moz_device_orientation@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_device_orientation: *mut nsIAtom; - #[link_name = "\x01?_moz_is_resource_document@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_is_resource_document: *mut nsIAtom; - #[link_name = "\x01?_moz_swipe_animation_enabled@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_swipe_animation_enabled: *mut nsIAtom; - #[link_name = "\x01?_moz_physical_home_button@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__moz_physical_home_button: *mut nsIAtom; - #[link_name = "\x01?Back@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_Back: *mut nsIAtom; - #[link_name = "\x01?Forward@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_Forward: *mut nsIAtom; - #[link_name = "\x01?Reload@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_Reload: *mut nsIAtom; - #[link_name = "\x01?Stop@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_Stop: *mut nsIAtom; - #[link_name = "\x01?Search@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_Search: *mut nsIAtom; - #[link_name = "\x01?Bookmarks@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_Bookmarks: *mut nsIAtom; - #[link_name = "\x01?Home@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_Home: *mut nsIAtom; - #[link_name = "\x01?Clear@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_Clear: *mut nsIAtom; - #[link_name = "\x01?VolumeUp@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_VolumeUp: *mut nsIAtom; - #[link_name = "\x01?VolumeDown@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_VolumeDown: *mut nsIAtom; - #[link_name = "\x01?NextTrack@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_NextTrack: *mut nsIAtom; - #[link_name = "\x01?PreviousTrack@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_PreviousTrack: *mut nsIAtom; - #[link_name = "\x01?MediaStop@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_MediaStop: *mut nsIAtom; - #[link_name = "\x01?PlayPause@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_PlayPause: *mut nsIAtom; - #[link_name = "\x01?Menu@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_Menu: *mut nsIAtom; - #[link_name = "\x01?New@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_New: *mut nsIAtom; - #[link_name = "\x01?Open@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_Open: *mut nsIAtom; - #[link_name = "\x01?Close@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_Close: *mut nsIAtom; - #[link_name = "\x01?Save@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_Save: *mut nsIAtom; - #[link_name = "\x01?Find@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_Find: *mut nsIAtom; - #[link_name = "\x01?Help@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_Help: *mut nsIAtom; - #[link_name = "\x01?Print@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_Print: *mut nsIAtom; - #[link_name = "\x01?SendMail@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_SendMail: *mut nsIAtom; - #[link_name = "\x01?ForwardMail@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ForwardMail: *mut nsIAtom; - #[link_name = "\x01?ReplyToMail@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ReplyToMail: *mut nsIAtom; - #[link_name = "\x01?mouseWheel@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mouseWheel: *mut nsIAtom; - #[link_name = "\x01?pixels@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pixels: *mut nsIAtom; - #[link_name = "\x01?lines@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lines: *mut nsIAtom; - #[link_name = "\x01?pages@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pages: *mut nsIAtom; - #[link_name = "\x01?scrollbars@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_scrollbars: *mut nsIAtom; - #[link_name = "\x01?other@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_other: *mut nsIAtom; - #[link_name = "\x01?apz@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_apz: *mut nsIAtom; - #[link_name = "\x01?restore@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_restore: *mut nsIAtom; - #[link_name = "\x01?alert@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_alert: *mut nsIAtom; - #[link_name = "\x01?alertdialog@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_alertdialog: *mut nsIAtom; - #[link_name = "\x01?application@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_application: *mut nsIAtom; - #[link_name = "\x01?aria_colcount@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_colcount: *mut nsIAtom; - #[link_name = "\x01?aria_colindex@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_colindex: *mut nsIAtom; - #[link_name = "\x01?aria_details@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_details: *mut nsIAtom; - #[link_name = "\x01?aria_errormessage@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_errormessage: *mut nsIAtom; - #[link_name = "\x01?aria_grabbed@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_grabbed: *mut nsIAtom; - #[link_name = "\x01?aria_label@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_label: *mut nsIAtom; - #[link_name = "\x01?aria_modal@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_modal: *mut nsIAtom; - #[link_name = "\x01?aria_orientation@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_orientation: *mut nsIAtom; - #[link_name = "\x01?aria_rowcount@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_rowcount: *mut nsIAtom; - #[link_name = "\x01?aria_rowindex@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_rowindex: *mut nsIAtom; - #[link_name = "\x01?aria_valuetext@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_valuetext: *mut nsIAtom; - #[link_name = "\x01?auto_generated@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_auto_generated: *mut nsIAtom; - #[link_name = "\x01?banner@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_banner: *mut nsIAtom; - #[link_name = "\x01?checkable@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_checkable: *mut nsIAtom; - #[link_name = "\x01?choices@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_choices: *mut nsIAtom; - #[link_name = "\x01?columnheader@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_columnheader: *mut nsIAtom; - #[link_name = "\x01?complementary@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_complementary: *mut nsIAtom; - #[link_name = "\x01?containerAtomic@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_containerAtomic: *mut nsIAtom; - #[link_name = "\x01?containerBusy@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_containerBusy: *mut nsIAtom; - #[link_name = "\x01?containerLive@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_containerLive: *mut nsIAtom; - #[link_name = "\x01?containerLiveRole@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_containerLiveRole: *mut nsIAtom; - #[link_name = "\x01?containerRelevant@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_containerRelevant: *mut nsIAtom; - #[link_name = "\x01?contentinfo@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_contentinfo: *mut nsIAtom; - #[link_name = "\x01?cycles@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_cycles: *mut nsIAtom; - #[link_name = "\x01?datatable@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_datatable: *mut nsIAtom; - #[link_name = "\x01?eventFromInput@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_eventFromInput: *mut nsIAtom; - #[link_name = "\x01?feed@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feed: *mut nsIAtom; - #[link_name = "\x01?grammar@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_grammar: *mut nsIAtom; - #[link_name = "\x01?gridcell@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_gridcell: *mut nsIAtom; - #[link_name = "\x01?heading@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_heading: *mut nsIAtom; - #[link_name = "\x01?hitregion@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_hitregion: *mut nsIAtom; - #[link_name = "\x01?inlinevalue@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_inlinevalue: *mut nsIAtom; - #[link_name = "\x01?invalid@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_invalid: *mut nsIAtom; - #[link_name = "\x01?item@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_item: *mut nsIAtom; - #[link_name = "\x01?itemset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_itemset: *mut nsIAtom; - #[link_name = "\x01?lineNumber@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lineNumber: *mut nsIAtom; - #[link_name = "\x01?linkedPanel@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_linkedPanel: *mut nsIAtom; - #[link_name = "\x01?live@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_live: *mut nsIAtom; - #[link_name = "\x01?menuitemcheckbox@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_menuitemcheckbox: *mut nsIAtom; - #[link_name = "\x01?menuitemradio@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_menuitemradio: *mut nsIAtom; - #[link_name = "\x01?mixed@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_mixed: *mut nsIAtom; - #[link_name = "\x01?multiline@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_multiline: *mut nsIAtom; - #[link_name = "\x01?navigation@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_navigation: *mut nsIAtom; - #[link_name = "\x01?polite@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_polite: *mut nsIAtom; - #[link_name = "\x01?posinset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_posinset: *mut nsIAtom; - #[link_name = "\x01?presentation@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_presentation: *mut nsIAtom; - #[link_name = "\x01?progressbar@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_progressbar: *mut nsIAtom; - #[link_name = "\x01?region@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_region: *mut nsIAtom; - #[link_name = "\x01?rowgroup@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rowgroup: *mut nsIAtom; - #[link_name = "\x01?rowheader@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rowheader: *mut nsIAtom; - #[link_name = "\x01?search@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_search: *mut nsIAtom; - #[link_name = "\x01?searchbox@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_searchbox: *mut nsIAtom; - #[link_name = "\x01?select1@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_select1: *mut nsIAtom; - #[link_name = "\x01?setsize@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_setsize: *mut nsIAtom; - #[link_name = "\x01?spelling@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_spelling: *mut nsIAtom; - #[link_name = "\x01?spinbutton@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_spinbutton: *mut nsIAtom; - #[link_name = "\x01?status@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_status: *mut nsIAtom; - #[link_name = "\x01?tableCellIndex@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tableCellIndex: *mut nsIAtom; - #[link_name = "\x01?tablist@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tablist: *mut nsIAtom; - #[link_name = "\x01?textIndent@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_textIndent: *mut nsIAtom; - #[link_name = "\x01?textInputType@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_textInputType: *mut nsIAtom; - #[link_name = "\x01?textLineThroughColor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_textLineThroughColor: *mut nsIAtom; - #[link_name = "\x01?textLineThroughStyle@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_textLineThroughStyle: *mut nsIAtom; - #[link_name = "\x01?textPosition@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_textPosition: *mut nsIAtom; - #[link_name = "\x01?textUnderlineColor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_textUnderlineColor: *mut nsIAtom; - #[link_name = "\x01?textUnderlineStyle@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_textUnderlineStyle: *mut nsIAtom; - #[link_name = "\x01?timer@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_timer: *mut nsIAtom; - #[link_name = "\x01?toolbarname@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_toolbarname: *mut nsIAtom; - #[link_name = "\x01?toolbarseparator@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_toolbarseparator: *mut nsIAtom; - #[link_name = "\x01?toolbarspacer@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_toolbarspacer: *mut nsIAtom; - #[link_name = "\x01?toolbarspring@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_toolbarspring: *mut nsIAtom; - #[link_name = "\x01?treegrid@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_treegrid: *mut nsIAtom; - #[link_name = "\x01?_undefined@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms__undefined: *mut nsIAtom; - #[link_name = "\x01?xmlroles@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xmlroles: *mut nsIAtom; - #[link_name = "\x01?close_fence@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_close_fence: *mut nsIAtom; - #[link_name = "\x01?denominator@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_denominator: *mut nsIAtom; - #[link_name = "\x01?numerator@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_numerator: *mut nsIAtom; - #[link_name = "\x01?open_fence@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_open_fence: *mut nsIAtom; - #[link_name = "\x01?overscript@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_overscript: *mut nsIAtom; - #[link_name = "\x01?presubscript@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_presubscript: *mut nsIAtom; - #[link_name = "\x01?presuperscript@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_presuperscript: *mut nsIAtom; - #[link_name = "\x01?root_index@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_root_index: *mut nsIAtom; - #[link_name = "\x01?subscript@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_subscript: *mut nsIAtom; - #[link_name = "\x01?superscript@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_superscript: *mut nsIAtom; - #[link_name = "\x01?underscript@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_underscript: *mut nsIAtom; - #[link_name = "\x01?onaudiostart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onaudiostart: *mut nsIAtom; - #[link_name = "\x01?onaudioend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onaudioend: *mut nsIAtom; - #[link_name = "\x01?onsoundstart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onsoundstart: *mut nsIAtom; - #[link_name = "\x01?onsoundend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onsoundend: *mut nsIAtom; - #[link_name = "\x01?onspeechstart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onspeechstart: *mut nsIAtom; - #[link_name = "\x01?onspeechend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onspeechend: *mut nsIAtom; - #[link_name = "\x01?onresult@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onresult: *mut nsIAtom; - #[link_name = "\x01?onnomatch@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onnomatch: *mut nsIAtom; - #[link_name = "\x01?onresume@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onresume: *mut nsIAtom; - #[link_name = "\x01?onmark@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmark: *mut nsIAtom; - #[link_name = "\x01?onboundary@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onboundary: *mut nsIAtom; - #[link_name = "\x01?usercontextid@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_usercontextid: *mut nsIAtom; - #[link_name = "\x01?nsuri_xmlns@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nsuri_xmlns: *mut nsIAtom; - #[link_name = "\x01?nsuri_xml@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nsuri_xml: *mut nsIAtom; - #[link_name = "\x01?nsuri_xhtml@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nsuri_xhtml: *mut nsIAtom; - #[link_name = "\x01?nsuri_xlink@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nsuri_xlink: *mut nsIAtom; - #[link_name = "\x01?nsuri_xslt@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nsuri_xslt: *mut nsIAtom; - #[link_name = "\x01?nsuri_xbl@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nsuri_xbl: *mut nsIAtom; - #[link_name = "\x01?nsuri_mathml@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nsuri_mathml: *mut nsIAtom; - #[link_name = "\x01?nsuri_rdf@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nsuri_rdf: *mut nsIAtom; - #[link_name = "\x01?nsuri_xul@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nsuri_xul: *mut nsIAtom; - #[link_name = "\x01?nsuri_svg@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_nsuri_svg: *mut nsIAtom; - #[link_name = "\x01?onsourceopen@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onsourceopen: *mut nsIAtom; - #[link_name = "\x01?onsourceended@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onsourceended: *mut nsIAtom; - #[link_name = "\x01?onsourceclosed@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onsourceclosed: *mut nsIAtom; - #[link_name = "\x01?onupdatestart@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onupdatestart: *mut nsIAtom; - #[link_name = "\x01?onupdate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onupdate: *mut nsIAtom; - #[link_name = "\x01?onupdateend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onupdateend: *mut nsIAtom; - #[link_name = "\x01?onaddsourcebuffer@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onaddsourcebuffer: *mut nsIAtom; - #[link_name = "\x01?onremovesourcebuffer@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onremovesourcebuffer: *mut nsIAtom; - #[link_name = "\x01?xlink@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xlink: *mut nsIAtom; - #[link_name = "\x01?xml_space@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xml_space: *mut nsIAtom; - #[link_name = "\x01?xml_lang@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xml_lang: *mut nsIAtom; - #[link_name = "\x01?xml_base@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xml_base: *mut nsIAtom; - #[link_name = "\x01?aria_grab@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_grab: *mut nsIAtom; - #[link_name = "\x01?aria_channel@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_channel: *mut nsIAtom; - #[link_name = "\x01?aria_secret@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_secret: *mut nsIAtom; - #[link_name = "\x01?aria_templateid@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_templateid: *mut nsIAtom; - #[link_name = "\x01?aria_datatype@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_aria_datatype: *mut nsIAtom; - #[link_name = "\x01?local@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_local: *mut nsIAtom; - #[link_name = "\x01?xchannelselector@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xchannelselector: *mut nsIAtom; - #[link_name = "\x01?ychannelselector@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_ychannelselector: *mut nsIAtom; - #[link_name = "\x01?enable_background@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_enable_background: *mut nsIAtom; - #[link_name = "\x01?calcmode@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_calcmode: *mut nsIAtom; - #[link_name = "\x01?specularexponent@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_specularexponent: *mut nsIAtom; - #[link_name = "\x01?specularconstant@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_specularconstant: *mut nsIAtom; - #[link_name = "\x01?gradienttransform@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_gradienttransform: *mut nsIAtom; - #[link_name = "\x01?gradientunits@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_gradientunits: *mut nsIAtom; - #[link_name = "\x01?rendering_intent@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_rendering_intent: *mut nsIAtom; - #[link_name = "\x01?stddeviation@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stddeviation: *mut nsIAtom; - #[link_name = "\x01?basefrequency@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_basefrequency: *mut nsIAtom; - #[link_name = "\x01?baseprofile@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_baseprofile: *mut nsIAtom; - #[link_name = "\x01?baseProfile@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_baseProfile: *mut nsIAtom; - #[link_name = "\x01?edgemode@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_edgemode: *mut nsIAtom; - #[link_name = "\x01?repeatcount@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_repeatcount: *mut nsIAtom; - #[link_name = "\x01?repeatdur@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_repeatdur: *mut nsIAtom; - #[link_name = "\x01?spreadmethod@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_spreadmethod: *mut nsIAtom; - #[link_name = "\x01?diffuseconstant@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_diffuseconstant: *mut nsIAtom; - #[link_name = "\x01?surfacescale@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_surfacescale: *mut nsIAtom; - #[link_name = "\x01?lengthadjust@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lengthadjust: *mut nsIAtom; - #[link_name = "\x01?origin@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_origin: *mut nsIAtom; - #[link_name = "\x01?targetx@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_targetx: *mut nsIAtom; - #[link_name = "\x01?targety@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_targety: *mut nsIAtom; - #[link_name = "\x01?pathlength@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pathlength: *mut nsIAtom; - #[link_name = "\x01?definitionurl@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_definitionurl: *mut nsIAtom; - #[link_name = "\x01?limitingconeangle@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_limitingconeangle: *mut nsIAtom; - #[link_name = "\x01?markerheight@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_markerheight: *mut nsIAtom; - #[link_name = "\x01?markerwidth@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_markerwidth: *mut nsIAtom; - #[link_name = "\x01?maskunits@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_maskunits: *mut nsIAtom; - #[link_name = "\x01?markerunits@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_markerunits: *mut nsIAtom; - #[link_name = "\x01?maskcontentunits@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_maskcontentunits: *mut nsIAtom; - #[link_name = "\x01?tablevalues@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_tablevalues: *mut nsIAtom; - #[link_name = "\x01?primitiveunits@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_primitiveunits: *mut nsIAtom; - #[link_name = "\x01?zoomandpan@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_zoomandpan: *mut nsIAtom; - #[link_name = "\x01?kernelmatrix@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_kernelmatrix: *mut nsIAtom; - #[link_name = "\x01?kerning@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_kerning: *mut nsIAtom; - #[link_name = "\x01?kernelunitlength@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_kernelunitlength: *mut nsIAtom; - #[link_name = "\x01?pointsatx@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pointsatx: *mut nsIAtom; - #[link_name = "\x01?pointsaty@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pointsaty: *mut nsIAtom; - #[link_name = "\x01?pointsatz@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_pointsatz: *mut nsIAtom; - #[link_name = "\x01?xlink_href@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xlink_href: *mut nsIAtom; - #[link_name = "\x01?xlink_title@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xlink_title: *mut nsIAtom; - #[link_name = "\x01?xlink_role@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xlink_role: *mut nsIAtom; - #[link_name = "\x01?xlink_arcrole@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xlink_arcrole: *mut nsIAtom; - #[link_name = "\x01?arcrole@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_arcrole: *mut nsIAtom; - #[link_name = "\x01?xmlns_xlink@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xmlns_xlink: *mut nsIAtom; - #[link_name = "\x01?xlink_type@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xlink_type: *mut nsIAtom; - #[link_name = "\x01?xlink_show@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xlink_show: *mut nsIAtom; - #[link_name = "\x01?xlink_actuate@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_xlink_actuate: *mut nsIAtom; - #[link_name = "\x01?color_rendering@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_color_rendering: *mut nsIAtom; - #[link_name = "\x01?numoctaves@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_numoctaves: *mut nsIAtom; - #[link_name = "\x01?onmousewheel@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_onmousewheel: *mut nsIAtom; - #[link_name = "\x01?clippathunits@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_clippathunits: *mut nsIAtom; - #[link_name = "\x01?glyph_orientation_vertical@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_glyph_orientation_vertical: *mut nsIAtom; - #[link_name = "\x01?glyph_orientation_horizontal@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_glyph_orientation_horizontal: *mut nsIAtom; - #[link_name = "\x01?glyphref@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_glyphref: *mut nsIAtom; - #[link_name = "\x01?keypoints@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_keypoints: *mut nsIAtom; - #[link_name = "\x01?attributename@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_attributename: *mut nsIAtom; - #[link_name = "\x01?attributetype@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_attributetype: *mut nsIAtom; - #[link_name = "\x01?startoffset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_startoffset: *mut nsIAtom; - #[link_name = "\x01?keysplines@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_keysplines: *mut nsIAtom; - #[link_name = "\x01?preservealpha@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_preservealpha: *mut nsIAtom; - #[link_name = "\x01?preserveaspectratio@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_preserveaspectratio: *mut nsIAtom; - #[link_name = "\x01?alttext@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_alttext: *mut nsIAtom; - #[link_name = "\x01?filterunits@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_filterunits: *mut nsIAtom; - #[link_name = "\x01?keytimes@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_keytimes: *mut nsIAtom; - #[link_name = "\x01?patterntransform@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_patterntransform: *mut nsIAtom; - #[link_name = "\x01?patternunits@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_patternunits: *mut nsIAtom; - #[link_name = "\x01?patterncontentunits@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_patterncontentunits: *mut nsIAtom; - #[link_name = "\x01?stitchtiles@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_stitchtiles: *mut nsIAtom; - #[link_name = "\x01?systemlanguage@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_systemlanguage: *mut nsIAtom; - #[link_name = "\x01?textlength@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_textlength: *mut nsIAtom; - #[link_name = "\x01?requiredfeatures@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_requiredfeatures: *mut nsIAtom; - #[link_name = "\x01?requiredextensions@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_requiredextensions: *mut nsIAtom; - #[link_name = "\x01?viewtarget@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_viewtarget: *mut nsIAtom; - #[link_name = "\x01?viewbox@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_viewbox: *mut nsIAtom; - #[link_name = "\x01?refx@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_refx: *mut nsIAtom; - #[link_name = "\x01?refy@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_refy: *mut nsIAtom; - #[link_name = "\x01?fefunca@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fefunca: *mut nsIAtom; - #[link_name = "\x01?fefuncb@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fefuncb: *mut nsIAtom; - #[link_name = "\x01?feblend@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feblend: *mut nsIAtom; - #[link_name = "\x01?feflood@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feflood: *mut nsIAtom; - #[link_name = "\x01?feturbulence@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feturbulence: *mut nsIAtom; - #[link_name = "\x01?femergenode@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_femergenode: *mut nsIAtom; - #[link_name = "\x01?feimage@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feimage: *mut nsIAtom; - #[link_name = "\x01?femerge@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_femerge: *mut nsIAtom; - #[link_name = "\x01?fetile@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fetile: *mut nsIAtom; - #[link_name = "\x01?fecomposite@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fecomposite: *mut nsIAtom; - #[link_name = "\x01?altglyphdef@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_altglyphdef: *mut nsIAtom; - #[link_name = "\x01?altGlyphDef@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_altGlyphDef: *mut nsIAtom; - #[link_name = "\x01?fefuncg@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fefuncg: *mut nsIAtom; - #[link_name = "\x01?fediffuselighting@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fediffuselighting: *mut nsIAtom; - #[link_name = "\x01?fespecularlighting@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fespecularlighting: *mut nsIAtom; - #[link_name = "\x01?altglyph@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_altglyph: *mut nsIAtom; - #[link_name = "\x01?altGlyph@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_altGlyph: *mut nsIAtom; - #[link_name = "\x01?clippath@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_clippath: *mut nsIAtom; - #[link_name = "\x01?textpath@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_textpath: *mut nsIAtom; - #[link_name = "\x01?altglyphitem@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_altglyphitem: *mut nsIAtom; - #[link_name = "\x01?altGlyphItem@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_altGlyphItem: *mut nsIAtom; - #[link_name = "\x01?animatetransform@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_animatetransform: *mut nsIAtom; - #[link_name = "\x01?animatemotion@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_animatemotion: *mut nsIAtom; - #[link_name = "\x01?fedisplacementmap@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fedisplacementmap: *mut nsIAtom; - #[link_name = "\x01?animatecolor@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_animatecolor: *mut nsIAtom; - #[link_name = "\x01?fefuncr@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fefuncr: *mut nsIAtom; - #[link_name = "\x01?fecomponenttransfer@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fecomponenttransfer: *mut nsIAtom; - #[link_name = "\x01?fegaussianblur@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fegaussianblur: *mut nsIAtom; - #[link_name = "\x01?foreignobject@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_foreignobject: *mut nsIAtom; - #[link_name = "\x01?feoffset@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feoffset: *mut nsIAtom; - #[link_name = "\x01?fespotlight@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fespotlight: *mut nsIAtom; - #[link_name = "\x01?fepointlight@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fepointlight: *mut nsIAtom; - #[link_name = "\x01?fedistantlight@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fedistantlight: *mut nsIAtom; - #[link_name = "\x01?lineargradient@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_lineargradient: *mut nsIAtom; - #[link_name = "\x01?radialgradient@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_radialgradient: *mut nsIAtom; - #[link_name = "\x01?fedropshadow@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fedropshadow: *mut nsIAtom; - #[link_name = "\x01?fecolormatrix@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_fecolormatrix: *mut nsIAtom; - #[link_name = "\x01?feconvolvematrix@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_feconvolvematrix: *mut nsIAtom; - #[link_name = "\x01?femorphology@nsGkAtoms@@2PAVnsIAtom@@A"] - pub static nsGkAtoms_femorphology: *mut nsIAtom; + #[link_name = "\x01?_empty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__empty: *mut nsAtom; + #[link_name = "\x01?moz@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_moz: *mut nsAtom; + #[link_name = "\x01?mozframetype@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozframetype: *mut nsAtom; + #[link_name = "\x01?_moz_abspos@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_abspos: *mut nsAtom; + #[link_name = "\x01?_moz_activated@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_activated: *mut nsAtom; + #[link_name = "\x01?_moz_anonclass@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_anonclass: *mut nsAtom; + #[link_name = "\x01?_moz_resizing@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_resizing: *mut nsAtom; + #[link_name = "\x01?mozallowfullscreen@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozallowfullscreen: *mut nsAtom; + #[link_name = "\x01?moztype@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_moztype: *mut nsAtom; + #[link_name = "\x01?mozdirty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozdirty: *mut nsAtom; + #[link_name = "\x01?mozdisallowselectionprint@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozdisallowselectionprint: *mut nsAtom; + #[link_name = "\x01?mozdonotsend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozdonotsend: *mut nsAtom; + #[link_name = "\x01?mozeditorbogusnode@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozeditorbogusnode: *mut nsAtom; + #[link_name = "\x01?mozgeneratedcontentbefore@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozgeneratedcontentbefore: *mut nsAtom; + #[link_name = "\x01?mozgeneratedcontentafter@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozgeneratedcontentafter: *mut nsAtom; + #[link_name = "\x01?mozgeneratedcontentimage@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozgeneratedcontentimage: *mut nsAtom; + #[link_name = "\x01?mozquote@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozquote: *mut nsAtom; + #[link_name = "\x01?mozsignature@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozsignature: *mut nsAtom; + #[link_name = "\x01?_moz_is_glyph@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_is_glyph: *mut nsAtom; + #[link_name = "\x01?_moz_original_size@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_original_size: *mut nsAtom; + #[link_name = "\x01?_moz_target@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_target: *mut nsAtom; + #[link_name = "\x01?menuactive@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_menuactive: *mut nsAtom; + #[link_name = "\x01?_poundDefault@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__poundDefault: *mut nsAtom; + #[link_name = "\x01?_asterisk@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__asterisk: *mut nsAtom; + #[link_name = "\x01?a@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_a: *mut nsAtom; + #[link_name = "\x01?abbr@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_abbr: *mut nsAtom; + #[link_name = "\x01?abort@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_abort: *mut nsAtom; + #[link_name = "\x01?above@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_above: *mut nsAtom; + #[link_name = "\x01?acceltext@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_acceltext: *mut nsAtom; + #[link_name = "\x01?accept@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_accept: *mut nsAtom; + #[link_name = "\x01?acceptcharset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_acceptcharset: *mut nsAtom; + #[link_name = "\x01?accesskey@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_accesskey: *mut nsAtom; + #[link_name = "\x01?acronym@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_acronym: *mut nsAtom; + #[link_name = "\x01?action@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_action: *mut nsAtom; + #[link_name = "\x01?active@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_active: *mut nsAtom; + #[link_name = "\x01?activetitlebarcolor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_activetitlebarcolor: *mut nsAtom; + #[link_name = "\x01?activateontab@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_activateontab: *mut nsAtom; + #[link_name = "\x01?actuate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_actuate: *mut nsAtom; + #[link_name = "\x01?address@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_address: *mut nsAtom; + #[link_name = "\x01?after@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_after: *mut nsAtom; + #[link_name = "\x01?after_end@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_after_end: *mut nsAtom; + #[link_name = "\x01?after_start@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_after_start: *mut nsAtom; + #[link_name = "\x01?align@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_align: *mut nsAtom; + #[link_name = "\x01?alink@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_alink: *mut nsAtom; + #[link_name = "\x01?all@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_all: *mut nsAtom; + #[link_name = "\x01?allowdirs@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_allowdirs: *mut nsAtom; + #[link_name = "\x01?allowevents@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_allowevents: *mut nsAtom; + #[link_name = "\x01?allownegativeassertions@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_allownegativeassertions: *mut nsAtom; + #[link_name = "\x01?allowforms@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_allowforms: *mut nsAtom; + #[link_name = "\x01?allowfullscreen@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_allowfullscreen: *mut nsAtom; + #[link_name = "\x01?allowmodals@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_allowmodals: *mut nsAtom; + #[link_name = "\x01?alloworientationlock@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_alloworientationlock: *mut nsAtom; + #[link_name = "\x01?allowpaymentrequest@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_allowpaymentrequest: *mut nsAtom; + #[link_name = "\x01?allowpointerlock@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_allowpointerlock: *mut nsAtom; + #[link_name = "\x01?allowpopupstoescapesandbox@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_allowpopupstoescapesandbox: *mut nsAtom; + #[link_name = "\x01?allowpopups@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_allowpopups: *mut nsAtom; + #[link_name = "\x01?allowpresentation@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_allowpresentation: *mut nsAtom; + #[link_name = "\x01?allowsameorigin@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_allowsameorigin: *mut nsAtom; + #[link_name = "\x01?allowscripts@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_allowscripts: *mut nsAtom; + #[link_name = "\x01?allowtopnavigation@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_allowtopnavigation: *mut nsAtom; + #[link_name = "\x01?allowuntrusted@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_allowuntrusted: *mut nsAtom; + #[link_name = "\x01?alt@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_alt: *mut nsAtom; + #[link_name = "\x01?alternate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_alternate: *mut nsAtom; + #[link_name = "\x01?always@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_always: *mut nsAtom; + #[link_name = "\x01?ancestor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ancestor: *mut nsAtom; + #[link_name = "\x01?ancestorOrSelf@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ancestorOrSelf: *mut nsAtom; + #[link_name = "\x01?anchor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_anchor: *mut nsAtom; + #[link_name = "\x01?_and@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__and: *mut nsAtom; + #[link_name = "\x01?animations@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_animations: *mut nsAtom; + #[link_name = "\x01?anonid@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_anonid: *mut nsAtom; + #[link_name = "\x01?anonlocation@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_anonlocation: *mut nsAtom; + #[link_name = "\x01?any@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_any: *mut nsAtom; + #[link_name = "\x01?applet@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_applet: *mut nsAtom; + #[link_name = "\x01?applyImports@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_applyImports: *mut nsAtom; + #[link_name = "\x01?applyTemplates@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_applyTemplates: *mut nsAtom; + #[link_name = "\x01?archive@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_archive: *mut nsAtom; + #[link_name = "\x01?area@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_area: *mut nsAtom; + #[link_name = "\x01?aria_activedescendant@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_activedescendant: *mut nsAtom; + #[link_name = "\x01?aria_atomic@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_atomic: *mut nsAtom; + #[link_name = "\x01?aria_autocomplete@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_autocomplete: *mut nsAtom; + #[link_name = "\x01?aria_busy@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_busy: *mut nsAtom; + #[link_name = "\x01?aria_checked@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_checked: *mut nsAtom; + #[link_name = "\x01?aria_controls@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_controls: *mut nsAtom; + #[link_name = "\x01?aria_current@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_current: *mut nsAtom; + #[link_name = "\x01?aria_describedby@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_describedby: *mut nsAtom; + #[link_name = "\x01?aria_disabled@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_disabled: *mut nsAtom; + #[link_name = "\x01?aria_dropeffect@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_dropeffect: *mut nsAtom; + #[link_name = "\x01?aria_expanded@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_expanded: *mut nsAtom; + #[link_name = "\x01?aria_flowto@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_flowto: *mut nsAtom; + #[link_name = "\x01?aria_haspopup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_haspopup: *mut nsAtom; + #[link_name = "\x01?aria_hidden@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_hidden: *mut nsAtom; + #[link_name = "\x01?aria_invalid@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_invalid: *mut nsAtom; + #[link_name = "\x01?aria_labelledby@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_labelledby: *mut nsAtom; + #[link_name = "\x01?aria_level@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_level: *mut nsAtom; + #[link_name = "\x01?aria_live@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_live: *mut nsAtom; + #[link_name = "\x01?aria_multiline@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_multiline: *mut nsAtom; + #[link_name = "\x01?aria_multiselectable@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_multiselectable: *mut nsAtom; + #[link_name = "\x01?aria_owns@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_owns: *mut nsAtom; + #[link_name = "\x01?aria_posinset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_posinset: *mut nsAtom; + #[link_name = "\x01?aria_pressed@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_pressed: *mut nsAtom; + #[link_name = "\x01?aria_readonly@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_readonly: *mut nsAtom; + #[link_name = "\x01?aria_relevant@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_relevant: *mut nsAtom; + #[link_name = "\x01?aria_required@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_required: *mut nsAtom; + #[link_name = "\x01?aria_selected@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_selected: *mut nsAtom; + #[link_name = "\x01?aria_setsize@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_setsize: *mut nsAtom; + #[link_name = "\x01?aria_sort@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_sort: *mut nsAtom; + #[link_name = "\x01?aria_valuemax@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_valuemax: *mut nsAtom; + #[link_name = "\x01?aria_valuemin@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_valuemin: *mut nsAtom; + #[link_name = "\x01?aria_valuenow@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_valuenow: *mut nsAtom; + #[link_name = "\x01?arrow@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_arrow: *mut nsAtom; + #[link_name = "\x01?article@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_article: *mut nsAtom; + #[link_name = "\x01?as@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_as: *mut nsAtom; + #[link_name = "\x01?ascending@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ascending: *mut nsAtom; + #[link_name = "\x01?aside@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aside: *mut nsAtom; + #[link_name = "\x01?aspectRatio@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aspectRatio: *mut nsAtom; + #[link_name = "\x01?assign@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_assign: *mut nsAtom; + #[link_name = "\x01?async@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_async: *mut nsAtom; + #[link_name = "\x01?attribute@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_attribute: *mut nsAtom; + #[link_name = "\x01?attributes@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_attributes: *mut nsAtom; + #[link_name = "\x01?attributeSet@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_attributeSet: *mut nsAtom; + #[link_name = "\x01?aural@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aural: *mut nsAtom; + #[link_name = "\x01?_auto@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__auto: *mut nsAtom; + #[link_name = "\x01?autocheck@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_autocheck: *mut nsAtom; + #[link_name = "\x01?autocomplete@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_autocomplete: *mut nsAtom; + #[link_name = "\x01?autofocus@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_autofocus: *mut nsAtom; + #[link_name = "\x01?autoplay@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_autoplay: *mut nsAtom; + #[link_name = "\x01?autorepeatbutton@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_autorepeatbutton: *mut nsAtom; + #[link_name = "\x01?axis@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_axis: *mut nsAtom; + #[link_name = "\x01?b@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_b: *mut nsAtom; + #[link_name = "\x01?background@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_background: *mut nsAtom; + #[link_name = "\x01?base@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_base: *mut nsAtom; + #[link_name = "\x01?basefont@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_basefont: *mut nsAtom; + #[link_name = "\x01?baseline@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_baseline: *mut nsAtom; + #[link_name = "\x01?bdi@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_bdi: *mut nsAtom; + #[link_name = "\x01?bdo@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_bdo: *mut nsAtom; + #[link_name = "\x01?before@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_before: *mut nsAtom; + #[link_name = "\x01?before_end@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_before_end: *mut nsAtom; + #[link_name = "\x01?before_start@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_before_start: *mut nsAtom; + #[link_name = "\x01?below@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_below: *mut nsAtom; + #[link_name = "\x01?bgcolor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_bgcolor: *mut nsAtom; + #[link_name = "\x01?bgsound@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_bgsound: *mut nsAtom; + #[link_name = "\x01?big@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_big: *mut nsAtom; + #[link_name = "\x01?binding@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_binding: *mut nsAtom; + #[link_name = "\x01?bindings@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_bindings: *mut nsAtom; + #[link_name = "\x01?bindToUntrustedContent@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_bindToUntrustedContent: *mut nsAtom; + #[link_name = "\x01?blankrow@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_blankrow: *mut nsAtom; + #[link_name = "\x01?block@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_block: *mut nsAtom; + #[link_name = "\x01?blockquote@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_blockquote: *mut nsAtom; + #[link_name = "\x01?blur@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_blur: *mut nsAtom; + #[link_name = "\x01?body@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_body: *mut nsAtom; + #[link_name = "\x01?boolean@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_boolean: *mut nsAtom; + #[link_name = "\x01?border@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_border: *mut nsAtom; + #[link_name = "\x01?bordercolor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_bordercolor: *mut nsAtom; + #[link_name = "\x01?both@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_both: *mut nsAtom; + #[link_name = "\x01?bottom@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_bottom: *mut nsAtom; + #[link_name = "\x01?bottomend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_bottomend: *mut nsAtom; + #[link_name = "\x01?bottomstart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_bottomstart: *mut nsAtom; + #[link_name = "\x01?bottomleft@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_bottomleft: *mut nsAtom; + #[link_name = "\x01?bottommargin@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_bottommargin: *mut nsAtom; + #[link_name = "\x01?bottompadding@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_bottompadding: *mut nsAtom; + #[link_name = "\x01?bottomright@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_bottomright: *mut nsAtom; + #[link_name = "\x01?box@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_box: *mut nsAtom; + #[link_name = "\x01?br@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_br: *mut nsAtom; + #[link_name = "\x01?braille@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_braille: *mut nsAtom; + #[link_name = "\x01?broadcast@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_broadcast: *mut nsAtom; + #[link_name = "\x01?broadcaster@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_broadcaster: *mut nsAtom; + #[link_name = "\x01?broadcasterset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_broadcasterset: *mut nsAtom; + #[link_name = "\x01?browser@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_browser: *mut nsAtom; + #[link_name = "\x01?mozbrowser@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozbrowser: *mut nsAtom; + #[link_name = "\x01?bulletinboard@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_bulletinboard: *mut nsAtom; + #[link_name = "\x01?button@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_button: *mut nsAtom; + #[link_name = "\x01?brighttitlebarforeground@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_brighttitlebarforeground: *mut nsAtom; + #[link_name = "\x01?callTemplate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_callTemplate: *mut nsAtom; + #[link_name = "\x01?cancel@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cancel: *mut nsAtom; + #[link_name = "\x01?canvas@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_canvas: *mut nsAtom; + #[link_name = "\x01?caption@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_caption: *mut nsAtom; + #[link_name = "\x01?capture@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_capture: *mut nsAtom; + #[link_name = "\x01?caseOrder@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_caseOrder: *mut nsAtom; + #[link_name = "\x01?cdataSectionElements@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cdataSectionElements: *mut nsAtom; + #[link_name = "\x01?ceiling@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ceiling: *mut nsAtom; + #[link_name = "\x01?cell@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cell: *mut nsAtom; + #[link_name = "\x01?cellpadding@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cellpadding: *mut nsAtom; + #[link_name = "\x01?cellspacing@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cellspacing: *mut nsAtom; + #[link_name = "\x01?center@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_center: *mut nsAtom; + #[link_name = "\x01?ch@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ch: *mut nsAtom; + #[link_name = "\x01?change@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_change: *mut nsAtom; + #[link_name = "\x01?_char@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__char: *mut nsAtom; + #[link_name = "\x01?characterData@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_characterData: *mut nsAtom; + #[link_name = "\x01?charcode@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_charcode: *mut nsAtom; + #[link_name = "\x01?charoff@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_charoff: *mut nsAtom; + #[link_name = "\x01?charset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_charset: *mut nsAtom; + #[link_name = "\x01?checkbox@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_checkbox: *mut nsAtom; + #[link_name = "\x01?checked@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_checked: *mut nsAtom; + #[link_name = "\x01?child@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_child: *mut nsAtom; + #[link_name = "\x01?children@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_children: *mut nsAtom; + #[link_name = "\x01?childList@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_childList: *mut nsAtom; + #[link_name = "\x01?choose@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_choose: *mut nsAtom; + #[link_name = "\x01?chromemargin@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_chromemargin: *mut nsAtom; + #[link_name = "\x01?chromeOnlyContent@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_chromeOnlyContent: *mut nsAtom; + #[link_name = "\x01?exposeToUntrustedContent@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_exposeToUntrustedContent: *mut nsAtom; + #[link_name = "\x01?circ@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_circ: *mut nsAtom; + #[link_name = "\x01?circle@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_circle: *mut nsAtom; + #[link_name = "\x01?cite@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cite: *mut nsAtom; + #[link_name = "\x01?cjkDecimal@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cjkDecimal: *mut nsAtom; + #[link_name = "\x01?_class@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__class: *mut nsAtom; + #[link_name = "\x01?classid@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_classid: *mut nsAtom; + #[link_name = "\x01?clear@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_clear: *mut nsAtom; + #[link_name = "\x01?click@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_click: *mut nsAtom; + #[link_name = "\x01?clickcount@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_clickcount: *mut nsAtom; + #[link_name = "\x01?clickthrough@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_clickthrough: *mut nsAtom; + #[link_name = "\x01?movetoclick@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_movetoclick: *mut nsAtom; + #[link_name = "\x01?clip@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_clip: *mut nsAtom; + #[link_name = "\x01?close@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_close: *mut nsAtom; + #[link_name = "\x01?closed@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_closed: *mut nsAtom; + #[link_name = "\x01?closemenu@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_closemenu: *mut nsAtom; + #[link_name = "\x01?coalesceduplicatearcs@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_coalesceduplicatearcs: *mut nsAtom; + #[link_name = "\x01?code@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_code: *mut nsAtom; + #[link_name = "\x01?codebase@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_codebase: *mut nsAtom; + #[link_name = "\x01?codetype@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_codetype: *mut nsAtom; + #[link_name = "\x01?col@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_col: *mut nsAtom; + #[link_name = "\x01?colgroup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_colgroup: *mut nsAtom; + #[link_name = "\x01?collapse@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_collapse: *mut nsAtom; + #[link_name = "\x01?collapsed@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_collapsed: *mut nsAtom; + #[link_name = "\x01?color@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_color: *mut nsAtom; + #[link_name = "\x01?colorIndex@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_colorIndex: *mut nsAtom; + #[link_name = "\x01?cols@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cols: *mut nsAtom; + #[link_name = "\x01?colspan@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_colspan: *mut nsAtom; + #[link_name = "\x01?column@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_column: *mut nsAtom; + #[link_name = "\x01?columns@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_columns: *mut nsAtom; + #[link_name = "\x01?combobox@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_combobox: *mut nsAtom; + #[link_name = "\x01?command@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_command: *mut nsAtom; + #[link_name = "\x01?commands@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_commands: *mut nsAtom; + #[link_name = "\x01?commandset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_commandset: *mut nsAtom; + #[link_name = "\x01?commandupdate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_commandupdate: *mut nsAtom; + #[link_name = "\x01?commandupdater@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_commandupdater: *mut nsAtom; + #[link_name = "\x01?comment@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_comment: *mut nsAtom; + #[link_name = "\x01?compact@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_compact: *mut nsAtom; + #[link_name = "\x01?concat@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_concat: *mut nsAtom; + #[link_name = "\x01?conditions@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_conditions: *mut nsAtom; + #[link_name = "\x01?constructor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_constructor: *mut nsAtom; + #[link_name = "\x01?consumeoutsideclicks@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_consumeoutsideclicks: *mut nsAtom; + #[link_name = "\x01?container@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_container: *mut nsAtom; + #[link_name = "\x01?containment@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_containment: *mut nsAtom; + #[link_name = "\x01?contains@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_contains: *mut nsAtom; + #[link_name = "\x01?content@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_content: *mut nsAtom; + #[link_name = "\x01?contenteditable@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_contenteditable: *mut nsAtom; + #[link_name = "\x01?headerContentDisposition@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_headerContentDisposition: *mut nsAtom; + #[link_name = "\x01?headerContentLanguage@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_headerContentLanguage: *mut nsAtom; + #[link_name = "\x01?contentLocation@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_contentLocation: *mut nsAtom; + #[link_name = "\x01?headerContentScriptType@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_headerContentScriptType: *mut nsAtom; + #[link_name = "\x01?headerContentStyleType@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_headerContentStyleType: *mut nsAtom; + #[link_name = "\x01?headerContentType@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_headerContentType: *mut nsAtom; + #[link_name = "\x01?consumeanchor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_consumeanchor: *mut nsAtom; + #[link_name = "\x01?context@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_context: *mut nsAtom; + #[link_name = "\x01?contextmenu@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_contextmenu: *mut nsAtom; + #[link_name = "\x01?control@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_control: *mut nsAtom; + #[link_name = "\x01?controls@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_controls: *mut nsAtom; + #[link_name = "\x01?coords@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_coords: *mut nsAtom; + #[link_name = "\x01?copy@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_copy: *mut nsAtom; + #[link_name = "\x01?copyOf@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_copyOf: *mut nsAtom; + #[link_name = "\x01?count@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_count: *mut nsAtom; + #[link_name = "\x01?crop@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_crop: *mut nsAtom; + #[link_name = "\x01?crossorigin@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_crossorigin: *mut nsAtom; + #[link_name = "\x01?curpos@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_curpos: *mut nsAtom; + #[link_name = "\x01?current@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_current: *mut nsAtom; + #[link_name = "\x01?cutoutregion@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cutoutregion: *mut nsAtom; + #[link_name = "\x01?cycler@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cycler: *mut nsAtom; + #[link_name = "\x01?data@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_data: *mut nsAtom; + #[link_name = "\x01?datalist@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_datalist: *mut nsAtom; + #[link_name = "\x01?dataType@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dataType: *mut nsAtom; + #[link_name = "\x01?dateTime@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dateTime: *mut nsAtom; + #[link_name = "\x01?datasources@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_datasources: *mut nsAtom; + #[link_name = "\x01?datetime@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_datetime: *mut nsAtom; + #[link_name = "\x01?datetimebox@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_datetimebox: *mut nsAtom; + #[link_name = "\x01?dblclick@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dblclick: *mut nsAtom; + #[link_name = "\x01?dd@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dd: *mut nsAtom; + #[link_name = "\x01?debug@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_debug: *mut nsAtom; + #[link_name = "\x01?decimal@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_decimal: *mut nsAtom; + #[link_name = "\x01?decimalFormat@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_decimalFormat: *mut nsAtom; + #[link_name = "\x01?decimalSeparator@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_decimalSeparator: *mut nsAtom; + #[link_name = "\x01?deck@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_deck: *mut nsAtom; + #[link_name = "\x01?declare@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_declare: *mut nsAtom; + #[link_name = "\x01?decoderDoctor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_decoderDoctor: *mut nsAtom; + #[link_name = "\x01?decrement@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_decrement: *mut nsAtom; + #[link_name = "\x01?_default@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__default: *mut nsAtom; + #[link_name = "\x01?headerDefaultStyle@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_headerDefaultStyle: *mut nsAtom; + #[link_name = "\x01?defaultAction@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_defaultAction: *mut nsAtom; + #[link_name = "\x01?defaultchecked@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_defaultchecked: *mut nsAtom; + #[link_name = "\x01?defaultLabel@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_defaultLabel: *mut nsAtom; + #[link_name = "\x01?defaultselected@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_defaultselected: *mut nsAtom; + #[link_name = "\x01?defaultvalue@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_defaultvalue: *mut nsAtom; + #[link_name = "\x01?defaultplaybackrate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_defaultplaybackrate: *mut nsAtom; + #[link_name = "\x01?defer@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_defer: *mut nsAtom; + #[link_name = "\x01?del@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_del: *mut nsAtom; + #[link_name = "\x01?descendant@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_descendant: *mut nsAtom; + #[link_name = "\x01?descendantOrSelf@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_descendantOrSelf: *mut nsAtom; + #[link_name = "\x01?descending@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_descending: *mut nsAtom; + #[link_name = "\x01?description@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_description: *mut nsAtom; + #[link_name = "\x01?destructor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_destructor: *mut nsAtom; + #[link_name = "\x01?details@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_details: *mut nsAtom; + #[link_name = "\x01?deviceAspectRatio@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_deviceAspectRatio: *mut nsAtom; + #[link_name = "\x01?deviceHeight@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_deviceHeight: *mut nsAtom; + #[link_name = "\x01?devicePixelRatio@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_devicePixelRatio: *mut nsAtom; + #[link_name = "\x01?deviceWidth@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_deviceWidth: *mut nsAtom; + #[link_name = "\x01?dfn@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dfn: *mut nsAtom; + #[link_name = "\x01?dialog@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dialog: *mut nsAtom; + #[link_name = "\x01?difference@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_difference: *mut nsAtom; + #[link_name = "\x01?digit@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_digit: *mut nsAtom; + #[link_name = "\x01?dir@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dir: *mut nsAtom; + #[link_name = "\x01?dirAutoSetBy@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dirAutoSetBy: *mut nsAtom; + #[link_name = "\x01?directionality@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_directionality: *mut nsAtom; + #[link_name = "\x01?directory@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_directory: *mut nsAtom; + #[link_name = "\x01?disableOutputEscaping@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_disableOutputEscaping: *mut nsAtom; + #[link_name = "\x01?disabled@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_disabled: *mut nsAtom; + #[link_name = "\x01?disableglobalhistory@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_disableglobalhistory: *mut nsAtom; + #[link_name = "\x01?disablehistory@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_disablehistory: *mut nsAtom; + #[link_name = "\x01?disablefullscreen@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_disablefullscreen: *mut nsAtom; + #[link_name = "\x01?disclosure_closed@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_disclosure_closed: *mut nsAtom; + #[link_name = "\x01?disclosure_open@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_disclosure_open: *mut nsAtom; + #[link_name = "\x01?display@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_display: *mut nsAtom; + #[link_name = "\x01?displayMode@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_displayMode: *mut nsAtom; + #[link_name = "\x01?distinct@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_distinct: *mut nsAtom; + #[link_name = "\x01?div@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_div: *mut nsAtom; + #[link_name = "\x01?dl@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dl: *mut nsAtom; + #[link_name = "\x01?docAbstract@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docAbstract: *mut nsAtom; + #[link_name = "\x01?docAcknowledgments@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docAcknowledgments: *mut nsAtom; + #[link_name = "\x01?docAfterword@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docAfterword: *mut nsAtom; + #[link_name = "\x01?docAppendix@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docAppendix: *mut nsAtom; + #[link_name = "\x01?docBacklink@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docBacklink: *mut nsAtom; + #[link_name = "\x01?docBiblioentry@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docBiblioentry: *mut nsAtom; + #[link_name = "\x01?docBibliography@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docBibliography: *mut nsAtom; + #[link_name = "\x01?docBiblioref@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docBiblioref: *mut nsAtom; + #[link_name = "\x01?docChapter@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docChapter: *mut nsAtom; + #[link_name = "\x01?docColophon@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docColophon: *mut nsAtom; + #[link_name = "\x01?docConclusion@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docConclusion: *mut nsAtom; + #[link_name = "\x01?docCover@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docCover: *mut nsAtom; + #[link_name = "\x01?docCredit@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docCredit: *mut nsAtom; + #[link_name = "\x01?docCredits@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docCredits: *mut nsAtom; + #[link_name = "\x01?docDedication@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docDedication: *mut nsAtom; + #[link_name = "\x01?docEndnote@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docEndnote: *mut nsAtom; + #[link_name = "\x01?docEndnotes@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docEndnotes: *mut nsAtom; + #[link_name = "\x01?docEpigraph@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docEpigraph: *mut nsAtom; + #[link_name = "\x01?docEpilogue@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docEpilogue: *mut nsAtom; + #[link_name = "\x01?docErrata@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docErrata: *mut nsAtom; + #[link_name = "\x01?docExample@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docExample: *mut nsAtom; + #[link_name = "\x01?docFootnote@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docFootnote: *mut nsAtom; + #[link_name = "\x01?docForeword@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docForeword: *mut nsAtom; + #[link_name = "\x01?docGlossary@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docGlossary: *mut nsAtom; + #[link_name = "\x01?docGlossref@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docGlossref: *mut nsAtom; + #[link_name = "\x01?docIndex@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docIndex: *mut nsAtom; + #[link_name = "\x01?docIntroduction@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docIntroduction: *mut nsAtom; + #[link_name = "\x01?docNoteref@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docNoteref: *mut nsAtom; + #[link_name = "\x01?docNotice@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docNotice: *mut nsAtom; + #[link_name = "\x01?docPagebreak@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docPagebreak: *mut nsAtom; + #[link_name = "\x01?docPagelist@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docPagelist: *mut nsAtom; + #[link_name = "\x01?docPart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docPart: *mut nsAtom; + #[link_name = "\x01?docPreface@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docPreface: *mut nsAtom; + #[link_name = "\x01?docPrologue@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docPrologue: *mut nsAtom; + #[link_name = "\x01?docPullquote@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docPullquote: *mut nsAtom; + #[link_name = "\x01?docQna@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docQna: *mut nsAtom; + #[link_name = "\x01?docSubtitle@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docSubtitle: *mut nsAtom; + #[link_name = "\x01?docTip@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docTip: *mut nsAtom; + #[link_name = "\x01?docToc@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_docToc: *mut nsAtom; + #[link_name = "\x01?doctypePublic@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_doctypePublic: *mut nsAtom; + #[link_name = "\x01?doctypeSystem@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_doctypeSystem: *mut nsAtom; + #[link_name = "\x01?document@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_document: *mut nsAtom; + #[link_name = "\x01?download@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_download: *mut nsAtom; + #[link_name = "\x01?DOMAttrModified@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_DOMAttrModified: *mut nsAtom; + #[link_name = "\x01?DOMCharacterDataModified@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_DOMCharacterDataModified: *mut nsAtom; + #[link_name = "\x01?DOMNodeInserted@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_DOMNodeInserted: *mut nsAtom; + #[link_name = "\x01?DOMNodeInsertedIntoDocument@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_DOMNodeInsertedIntoDocument: *mut nsAtom; + #[link_name = "\x01?DOMNodeRemoved@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_DOMNodeRemoved: *mut nsAtom; + #[link_name = "\x01?DOMNodeRemovedFromDocument@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_DOMNodeRemovedFromDocument: *mut nsAtom; + #[link_name = "\x01?DOMSubtreeModified@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_DOMSubtreeModified: *mut nsAtom; + #[link_name = "\x01?double_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_double_: *mut nsAtom; + #[link_name = "\x01?drag@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_drag: *mut nsAtom; + #[link_name = "\x01?dragend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dragend: *mut nsAtom; + #[link_name = "\x01?dragenter@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dragenter: *mut nsAtom; + #[link_name = "\x01?dragevent@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dragevent: *mut nsAtom; + #[link_name = "\x01?dragexit@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dragexit: *mut nsAtom; + #[link_name = "\x01?draggable@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_draggable: *mut nsAtom; + #[link_name = "\x01?dragging@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dragging: *mut nsAtom; + #[link_name = "\x01?dragleave@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dragleave: *mut nsAtom; + #[link_name = "\x01?dragover@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dragover: *mut nsAtom; + #[link_name = "\x01?dragSession@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dragSession: *mut nsAtom; + #[link_name = "\x01?dragstart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dragstart: *mut nsAtom; + #[link_name = "\x01?drawintitlebar@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_drawintitlebar: *mut nsAtom; + #[link_name = "\x01?drawtitle@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_drawtitle: *mut nsAtom; + #[link_name = "\x01?drop@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_drop: *mut nsAtom; + #[link_name = "\x01?dropAfter@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dropAfter: *mut nsAtom; + #[link_name = "\x01?dropBefore@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dropBefore: *mut nsAtom; + #[link_name = "\x01?dropOn@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dropOn: *mut nsAtom; + #[link_name = "\x01?dropMarker@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dropMarker: *mut nsAtom; + #[link_name = "\x01?dt@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dt: *mut nsAtom; + #[link_name = "\x01?editable@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_editable: *mut nsAtom; + #[link_name = "\x01?editing@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_editing: *mut nsAtom; + #[link_name = "\x01?editor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_editor: *mut nsAtom; + #[link_name = "\x01?editorDisplayList@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_editorDisplayList: *mut nsAtom; + #[link_name = "\x01?element@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_element: *mut nsAtom; + #[link_name = "\x01?elementAvailable@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_elementAvailable: *mut nsAtom; + #[link_name = "\x01?elements@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_elements: *mut nsAtom; + #[link_name = "\x01?em@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_em: *mut nsAtom; + #[link_name = "\x01?embed@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_embed: *mut nsAtom; + #[link_name = "\x01?embossed@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_embossed: *mut nsAtom; + #[link_name = "\x01?empty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_empty: *mut nsAtom; + #[link_name = "\x01?encoding@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_encoding: *mut nsAtom; + #[link_name = "\x01?enctype@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_enctype: *mut nsAtom; + #[link_name = "\x01?end@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_end: *mut nsAtom; + #[link_name = "\x01?endEvent@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_endEvent: *mut nsAtom; + #[link_name = "\x01?end_after@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_end_after: *mut nsAtom; + #[link_name = "\x01?end_before@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_end_before: *mut nsAtom; + #[link_name = "\x01?equalsize@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_equalsize: *mut nsAtom; + #[link_name = "\x01?error@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_error: *mut nsAtom; + #[link_name = "\x01?ethiopic_numeric@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ethiopic_numeric: *mut nsAtom; + #[link_name = "\x01?even@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_even: *mut nsAtom; + #[link_name = "\x01?event@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_event: *mut nsAtom; + #[link_name = "\x01?events@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_events: *mut nsAtom; + #[link_name = "\x01?excludeResultPrefixes@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_excludeResultPrefixes: *mut nsAtom; + #[link_name = "\x01?excludes@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_excludes: *mut nsAtom; + #[link_name = "\x01?expr@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_expr: *mut nsAtom; + #[link_name = "\x01?extends@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_extends: *mut nsAtom; + #[link_name = "\x01?extensionElementPrefixes@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_extensionElementPrefixes: *mut nsAtom; + #[link_name = "\x01?face@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_face: *mut nsAtom; + #[link_name = "\x01?fallback@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fallback: *mut nsAtom; + #[link_name = "\x01?_false@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__false: *mut nsAtom; + #[link_name = "\x01?farthest@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_farthest: *mut nsAtom; + #[link_name = "\x01?field@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_field: *mut nsAtom; + #[link_name = "\x01?fieldset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fieldset: *mut nsAtom; + #[link_name = "\x01?file@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_file: *mut nsAtom; + #[link_name = "\x01?figcaption@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_figcaption: *mut nsAtom; + #[link_name = "\x01?figure@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_figure: *mut nsAtom; + #[link_name = "\x01?fixed@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fixed: *mut nsAtom; + #[link_name = "\x01?flags@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_flags: *mut nsAtom; + #[link_name = "\x01?flex@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_flex: *mut nsAtom; + #[link_name = "\x01?flexgroup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_flexgroup: *mut nsAtom; + #[link_name = "\x01?flip@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_flip: *mut nsAtom; + #[link_name = "\x01?floating@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_floating: *mut nsAtom; + #[link_name = "\x01?floor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_floor: *mut nsAtom; + #[link_name = "\x01?flowlength@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_flowlength: *mut nsAtom; + #[link_name = "\x01?focus@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_focus: *mut nsAtom; + #[link_name = "\x01?focused@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_focused: *mut nsAtom; + #[link_name = "\x01?followanchor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_followanchor: *mut nsAtom; + #[link_name = "\x01?following@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_following: *mut nsAtom; + #[link_name = "\x01?followingSibling@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_followingSibling: *mut nsAtom; + #[link_name = "\x01?font@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_font: *mut nsAtom; + #[link_name = "\x01?fontWeight@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fontWeight: *mut nsAtom; + #[link_name = "\x01?fontpicker@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fontpicker: *mut nsAtom; + #[link_name = "\x01?footer@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_footer: *mut nsAtom; + #[link_name = "\x01?_for@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__for: *mut nsAtom; + #[link_name = "\x01?forEach@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_forEach: *mut nsAtom; + #[link_name = "\x01?forceOwnRefreshDriver@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_forceOwnRefreshDriver: *mut nsAtom; + #[link_name = "\x01?form@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_form: *mut nsAtom; + #[link_name = "\x01?formaction@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_formaction: *mut nsAtom; + #[link_name = "\x01?format@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_format: *mut nsAtom; + #[link_name = "\x01?formatNumber@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_formatNumber: *mut nsAtom; + #[link_name = "\x01?formenctype@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_formenctype: *mut nsAtom; + #[link_name = "\x01?formmethod@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_formmethod: *mut nsAtom; + #[link_name = "\x01?formnovalidate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_formnovalidate: *mut nsAtom; + #[link_name = "\x01?formtarget@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_formtarget: *mut nsAtom; + #[link_name = "\x01?frame@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_frame: *mut nsAtom; + #[link_name = "\x01?frameborder@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_frameborder: *mut nsAtom; + #[link_name = "\x01?frameset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_frameset: *mut nsAtom; + #[link_name = "\x01?from@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_from: *mut nsAtom; + #[link_name = "\x01?fullscreenchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fullscreenchange: *mut nsAtom; + #[link_name = "\x01?fullscreenerror@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fullscreenerror: *mut nsAtom; + #[link_name = "\x01?functionAvailable@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_functionAvailable: *mut nsAtom; + #[link_name = "\x01?freshProcess@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_freshProcess: *mut nsAtom; + #[link_name = "\x01?generateId@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_generateId: *mut nsAtom; + #[link_name = "\x01?getter@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_getter: *mut nsAtom; + #[link_name = "\x01?glyphchar@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_glyphchar: *mut nsAtom; + #[link_name = "\x01?glyphid@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_glyphid: *mut nsAtom; + #[link_name = "\x01?grid@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_grid: *mut nsAtom; + #[link_name = "\x01?grippy@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_grippy: *mut nsAtom; + #[link_name = "\x01?group@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_group: *mut nsAtom; + #[link_name = "\x01?groupingSeparator@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_groupingSeparator: *mut nsAtom; + #[link_name = "\x01?groupingSize@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_groupingSize: *mut nsAtom; + #[link_name = "\x01?grow@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_grow: *mut nsAtom; + #[link_name = "\x01?gutter@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_gutter: *mut nsAtom; + #[link_name = "\x01?h1@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_h1: *mut nsAtom; + #[link_name = "\x01?h2@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_h2: *mut nsAtom; + #[link_name = "\x01?h3@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_h3: *mut nsAtom; + #[link_name = "\x01?h4@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_h4: *mut nsAtom; + #[link_name = "\x01?h5@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_h5: *mut nsAtom; + #[link_name = "\x01?h6@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_h6: *mut nsAtom; + #[link_name = "\x01?handheld@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_handheld: *mut nsAtom; + #[link_name = "\x01?handheldFriendly@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_handheldFriendly: *mut nsAtom; + #[link_name = "\x01?handler@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_handler: *mut nsAtom; + #[link_name = "\x01?handlers@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_handlers: *mut nsAtom; + #[link_name = "\x01?HARD@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_HARD: *mut nsAtom; + #[link_name = "\x01?haspopup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_haspopup: *mut nsAtom; + #[link_name = "\x01?hasSameNode@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_hasSameNode: *mut nsAtom; + #[link_name = "\x01?hbox@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_hbox: *mut nsAtom; + #[link_name = "\x01?head@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_head: *mut nsAtom; + #[link_name = "\x01?header@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_header: *mut nsAtom; + #[link_name = "\x01?headers@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_headers: *mut nsAtom; + #[link_name = "\x01?hebrew@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_hebrew: *mut nsAtom; + #[link_name = "\x01?height@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_height: *mut nsAtom; + #[link_name = "\x01?hgroup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_hgroup: *mut nsAtom; + #[link_name = "\x01?hidden@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_hidden: *mut nsAtom; + #[link_name = "\x01?hidechrome@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_hidechrome: *mut nsAtom; + #[link_name = "\x01?hidecolumnpicker@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_hidecolumnpicker: *mut nsAtom; + #[link_name = "\x01?high@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_high: *mut nsAtom; + #[link_name = "\x01?highest@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_highest: *mut nsAtom; + #[link_name = "\x01?horizontal@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_horizontal: *mut nsAtom; + #[link_name = "\x01?hover@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_hover: *mut nsAtom; + #[link_name = "\x01?hr@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_hr: *mut nsAtom; + #[link_name = "\x01?href@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_href: *mut nsAtom; + #[link_name = "\x01?hreflang@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_hreflang: *mut nsAtom; + #[link_name = "\x01?hspace@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_hspace: *mut nsAtom; + #[link_name = "\x01?html@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_html: *mut nsAtom; + #[link_name = "\x01?httpEquiv@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_httpEquiv: *mut nsAtom; + #[link_name = "\x01?i@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_i: *mut nsAtom; + #[link_name = "\x01?icon@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_icon: *mut nsAtom; + #[link_name = "\x01?id@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_id: *mut nsAtom; + #[link_name = "\x01?_if@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__if: *mut nsAtom; + #[link_name = "\x01?iframe@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_iframe: *mut nsAtom; + #[link_name = "\x01?ignorecase@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ignorecase: *mut nsAtom; + #[link_name = "\x01?ignorekeys@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ignorekeys: *mut nsAtom; + #[link_name = "\x01?ignoreuserfocus@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ignoreuserfocus: *mut nsAtom; + #[link_name = "\x01?ilayer@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ilayer: *mut nsAtom; + #[link_name = "\x01?image@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_image: *mut nsAtom; + #[link_name = "\x01?imageClickedPoint@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_imageClickedPoint: *mut nsAtom; + #[link_name = "\x01?img@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_img: *mut nsAtom; + #[link_name = "\x01?implementation@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_implementation: *mut nsAtom; + #[link_name = "\x01?implements@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_implements: *mut nsAtom; + #[link_name = "\x01?import@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_import: *mut nsAtom; + #[link_name = "\x01?inactivetitlebarcolor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_inactivetitlebarcolor: *mut nsAtom; + #[link_name = "\x01?include@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_include: *mut nsAtom; + #[link_name = "\x01?includes@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_includes: *mut nsAtom; + #[link_name = "\x01?increment@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_increment: *mut nsAtom; + #[link_name = "\x01?indent@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_indent: *mut nsAtom; + #[link_name = "\x01?indeterminate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_indeterminate: *mut nsAtom; + #[link_name = "\x01?index@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_index: *mut nsAtom; + #[link_name = "\x01?infer@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_infer: *mut nsAtom; + #[link_name = "\x01?infinity@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_infinity: *mut nsAtom; + #[link_name = "\x01?inherit@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_inherit: *mut nsAtom; + #[link_name = "\x01?inherits@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_inherits: *mut nsAtom; + #[link_name = "\x01?inheritstyle@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_inheritstyle: *mut nsAtom; + #[link_name = "\x01?initial_scale@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_initial_scale: *mut nsAtom; + #[link_name = "\x01?input@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_input: *mut nsAtom; + #[link_name = "\x01?inputmode@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_inputmode: *mut nsAtom; + #[link_name = "\x01?ins@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ins: *mut nsAtom; + #[link_name = "\x01?insertafter@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_insertafter: *mut nsAtom; + #[link_name = "\x01?insertbefore@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_insertbefore: *mut nsAtom; + #[link_name = "\x01?install@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_install: *mut nsAtom; + #[link_name = "\x01?instanceOf@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_instanceOf: *mut nsAtom; + #[link_name = "\x01?int32@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_int32: *mut nsAtom; + #[link_name = "\x01?int64@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_int64: *mut nsAtom; + #[link_name = "\x01?integer@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_integer: *mut nsAtom; + #[link_name = "\x01?integrity@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_integrity: *mut nsAtom; + #[link_name = "\x01?intersection@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_intersection: *mut nsAtom; + #[link_name = "\x01?is@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_is: *mut nsAtom; + #[link_name = "\x01?iscontainer@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_iscontainer: *mut nsAtom; + #[link_name = "\x01?isempty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_isempty: *mut nsAtom; + #[link_name = "\x01?ismap@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ismap: *mut nsAtom; + #[link_name = "\x01?itemid@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_itemid: *mut nsAtom; + #[link_name = "\x01?itemprop@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_itemprop: *mut nsAtom; + #[link_name = "\x01?itemref@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_itemref: *mut nsAtom; + #[link_name = "\x01?itemscope@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_itemscope: *mut nsAtom; + #[link_name = "\x01?itemtype@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_itemtype: *mut nsAtom; + #[link_name = "\x01?japanese_formal@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_japanese_formal: *mut nsAtom; + #[link_name = "\x01?japanese_informal@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_japanese_informal: *mut nsAtom; + #[link_name = "\x01?kbd@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_kbd: *mut nsAtom; + #[link_name = "\x01?keepcurrentinview@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_keepcurrentinview: *mut nsAtom; + #[link_name = "\x01?keepobjectsalive@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_keepobjectsalive: *mut nsAtom; + #[link_name = "\x01?key@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_key: *mut nsAtom; + #[link_name = "\x01?keycode@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_keycode: *mut nsAtom; + #[link_name = "\x01?keystatuseschange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_keystatuseschange: *mut nsAtom; + #[link_name = "\x01?keydown@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_keydown: *mut nsAtom; + #[link_name = "\x01?keygen@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_keygen: *mut nsAtom; + #[link_name = "\x01?keypress@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_keypress: *mut nsAtom; + #[link_name = "\x01?keyset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_keyset: *mut nsAtom; + #[link_name = "\x01?keysystem@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_keysystem: *mut nsAtom; + #[link_name = "\x01?keytext@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_keytext: *mut nsAtom; + #[link_name = "\x01?keyup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_keyup: *mut nsAtom; + #[link_name = "\x01?kind@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_kind: *mut nsAtom; + #[link_name = "\x01?korean_hangul_formal@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_korean_hangul_formal: *mut nsAtom; + #[link_name = "\x01?korean_hanja_formal@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_korean_hanja_formal: *mut nsAtom; + #[link_name = "\x01?korean_hanja_informal@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_korean_hanja_informal: *mut nsAtom; + #[link_name = "\x01?label@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_label: *mut nsAtom; + #[link_name = "\x01?labels@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_labels: *mut nsAtom; + #[link_name = "\x01?lang@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lang: *mut nsAtom; + #[link_name = "\x01?language@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_language: *mut nsAtom; + #[link_name = "\x01?last@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_last: *mut nsAtom; + #[link_name = "\x01?layer@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_layer: *mut nsAtom; + #[link_name = "\x01?LayerActivity@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_LayerActivity: *mut nsAtom; + #[link_name = "\x01?layout@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_layout: *mut nsAtom; + #[link_name = "\x01?leading@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_leading: *mut nsAtom; + #[link_name = "\x01?leaf@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_leaf: *mut nsAtom; + #[link_name = "\x01?left@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_left: *mut nsAtom; + #[link_name = "\x01?leftmargin@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_leftmargin: *mut nsAtom; + #[link_name = "\x01?leftpadding@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_leftpadding: *mut nsAtom; + #[link_name = "\x01?legend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_legend: *mut nsAtom; + #[link_name = "\x01?length@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_length: *mut nsAtom; + #[link_name = "\x01?letterValue@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_letterValue: *mut nsAtom; + #[link_name = "\x01?level@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_level: *mut nsAtom; + #[link_name = "\x01?li@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_li: *mut nsAtom; + #[link_name = "\x01?line@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_line: *mut nsAtom; + #[link_name = "\x01?link@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_link: *mut nsAtom; + #[link_name = "\x01?list@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_list: *mut nsAtom; + #[link_name = "\x01?listbox@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_listbox: *mut nsAtom; + #[link_name = "\x01?listboxbody@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_listboxbody: *mut nsAtom; + #[link_name = "\x01?listcell@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_listcell: *mut nsAtom; + #[link_name = "\x01?listcol@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_listcol: *mut nsAtom; + #[link_name = "\x01?listcols@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_listcols: *mut nsAtom; + #[link_name = "\x01?listener@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_listener: *mut nsAtom; + #[link_name = "\x01?listhead@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_listhead: *mut nsAtom; + #[link_name = "\x01?listheader@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_listheader: *mut nsAtom; + #[link_name = "\x01?listing@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_listing: *mut nsAtom; + #[link_name = "\x01?listitem@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_listitem: *mut nsAtom; + #[link_name = "\x01?listrows@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_listrows: *mut nsAtom; + #[link_name = "\x01?load@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_load: *mut nsAtom; + #[link_name = "\x01?loadingprincipal@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_loadingprincipal: *mut nsAtom; + #[link_name = "\x01?localedir@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_localedir: *mut nsAtom; + #[link_name = "\x01?localName@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_localName: *mut nsAtom; + #[link_name = "\x01?longdesc@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_longdesc: *mut nsAtom; + #[link_name = "\x01?loop@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_loop: *mut nsAtom; + #[link_name = "\x01?low@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_low: *mut nsAtom; + #[link_name = "\x01?lowerAlpha@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lowerAlpha: *mut nsAtom; + #[link_name = "\x01?lowerFirst@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lowerFirst: *mut nsAtom; + #[link_name = "\x01?lowerRoman@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lowerRoman: *mut nsAtom; + #[link_name = "\x01?lowest@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lowest: *mut nsAtom; + #[link_name = "\x01?lowsrc@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lowsrc: *mut nsAtom; + #[link_name = "\x01?ltr@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ltr: *mut nsAtom; + #[link_name = "\x01?lwtheme@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lwtheme: *mut nsAtom; + #[link_name = "\x01?lwthemetextcolor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lwthemetextcolor: *mut nsAtom; + #[link_name = "\x01?main@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_main: *mut nsAtom; + #[link_name = "\x01?map@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_map: *mut nsAtom; + #[link_name = "\x01?manifest@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_manifest: *mut nsAtom; + #[link_name = "\x01?marginBottom@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_marginBottom: *mut nsAtom; + #[link_name = "\x01?marginLeft@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_marginLeft: *mut nsAtom; + #[link_name = "\x01?marginRight@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_marginRight: *mut nsAtom; + #[link_name = "\x01?marginTop@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_marginTop: *mut nsAtom; + #[link_name = "\x01?marginheight@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_marginheight: *mut nsAtom; + #[link_name = "\x01?marginwidth@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_marginwidth: *mut nsAtom; + #[link_name = "\x01?mark@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mark: *mut nsAtom; + #[link_name = "\x01?marquee@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_marquee: *mut nsAtom; + #[link_name = "\x01?match@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_match: *mut nsAtom; + #[link_name = "\x01?max@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_max: *mut nsAtom; + #[link_name = "\x01?maxheight@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_maxheight: *mut nsAtom; + #[link_name = "\x01?maximum_scale@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_maximum_scale: *mut nsAtom; + #[link_name = "\x01?maxlength@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_maxlength: *mut nsAtom; + #[link_name = "\x01?maxpos@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_maxpos: *mut nsAtom; + #[link_name = "\x01?maxwidth@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_maxwidth: *mut nsAtom; + #[link_name = "\x01?mayscript@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mayscript: *mut nsAtom; + #[link_name = "\x01?media@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_media: *mut nsAtom; + #[link_name = "\x01?mediaType@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mediaType: *mut nsAtom; + #[link_name = "\x01?member@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_member: *mut nsAtom; + #[link_name = "\x01?menu@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_menu: *mut nsAtom; + #[link_name = "\x01?menubar@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_menubar: *mut nsAtom; + #[link_name = "\x01?menubutton@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_menubutton: *mut nsAtom; + #[link_name = "\x01?menuButton@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_menuButton: *mut nsAtom; + #[link_name = "\x01?menugroup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_menugroup: *mut nsAtom; + #[link_name = "\x01?menuitem@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_menuitem: *mut nsAtom; + #[link_name = "\x01?menulist@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_menulist: *mut nsAtom; + #[link_name = "\x01?menupopup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_menupopup: *mut nsAtom; + #[link_name = "\x01?menuseparator@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_menuseparator: *mut nsAtom; + #[link_name = "\x01?message@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_message: *mut nsAtom; + #[link_name = "\x01?meta@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_meta: *mut nsAtom; + #[link_name = "\x01?referrer@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_referrer: *mut nsAtom; + #[link_name = "\x01?referrerpolicy@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_referrerpolicy: *mut nsAtom; + #[link_name = "\x01?headerReferrerPolicy@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_headerReferrerPolicy: *mut nsAtom; + #[link_name = "\x01?meter@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_meter: *mut nsAtom; + #[link_name = "\x01?method@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_method: *mut nsAtom; + #[link_name = "\x01?middle@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_middle: *mut nsAtom; + #[link_name = "\x01?min@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_min: *mut nsAtom; + #[link_name = "\x01?minheight@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_minheight: *mut nsAtom; + #[link_name = "\x01?minimum_scale@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_minimum_scale: *mut nsAtom; + #[link_name = "\x01?minlength@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_minlength: *mut nsAtom; + #[link_name = "\x01?minpos@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_minpos: *mut nsAtom; + #[link_name = "\x01?minusSign@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_minusSign: *mut nsAtom; + #[link_name = "\x01?minwidth@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_minwidth: *mut nsAtom; + #[link_name = "\x01?_mixed@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__mixed: *mut nsAtom; + #[link_name = "\x01?messagemanagergroup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_messagemanagergroup: *mut nsAtom; + #[link_name = "\x01?mod@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mod: *mut nsAtom; + #[link_name = "\x01?mode@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mode: *mut nsAtom; + #[link_name = "\x01?modifiers@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_modifiers: *mut nsAtom; + #[link_name = "\x01?monochrome@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_monochrome: *mut nsAtom; + #[link_name = "\x01?mousedown@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mousedown: *mut nsAtom; + #[link_name = "\x01?mousemove@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mousemove: *mut nsAtom; + #[link_name = "\x01?mouseout@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mouseout: *mut nsAtom; + #[link_name = "\x01?mouseover@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mouseover: *mut nsAtom; + #[link_name = "\x01?mousethrough@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mousethrough: *mut nsAtom; + #[link_name = "\x01?mouseup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mouseup: *mut nsAtom; + #[link_name = "\x01?mozfullscreenchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozfullscreenchange: *mut nsAtom; + #[link_name = "\x01?mozfullscreenerror@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozfullscreenerror: *mut nsAtom; + #[link_name = "\x01?mozpointerlockchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozpointerlockchange: *mut nsAtom; + #[link_name = "\x01?mozpointerlockerror@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozpointerlockerror: *mut nsAtom; + #[link_name = "\x01?mozprivatebrowsing@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozprivatebrowsing: *mut nsAtom; + #[link_name = "\x01?moz_opaque@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_moz_opaque: *mut nsAtom; + #[link_name = "\x01?moz_action_hint@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_moz_action_hint: *mut nsAtom; + #[link_name = "\x01?x_moz_errormessage@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x_moz_errormessage: *mut nsAtom; + #[link_name = "\x01?multicol@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_multicol: *mut nsAtom; + #[link_name = "\x01?multiple@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_multiple: *mut nsAtom; + #[link_name = "\x01?muted@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_muted: *mut nsAtom; + #[link_name = "\x01?name@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_name: *mut nsAtom; + #[link_name = "\x01?_namespace@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__namespace: *mut nsAtom; + #[link_name = "\x01?namespaceAlias@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_namespaceAlias: *mut nsAtom; + #[link_name = "\x01?namespaceUri@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_namespaceUri: *mut nsAtom; + #[link_name = "\x01?NaN@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_NaN: *mut nsAtom; + #[link_name = "\x01?nativeAnonymousChildList@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nativeAnonymousChildList: *mut nsAtom; + #[link_name = "\x01?nav@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nav: *mut nsAtom; + #[link_name = "\x01?negate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_negate: *mut nsAtom; + #[link_name = "\x01?never@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_never: *mut nsAtom; + #[link_name = "\x01?_new@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__new: *mut nsAtom; + #[link_name = "\x01?newline@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_newline: *mut nsAtom; + #[link_name = "\x01?nextBidi@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nextBidi: *mut nsAtom; + #[link_name = "\x01?nextTabParentId@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nextTabParentId: *mut nsAtom; + #[link_name = "\x01?no@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_no: *mut nsAtom; + #[link_name = "\x01?noautofocus@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_noautofocus: *mut nsAtom; + #[link_name = "\x01?noautohide@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_noautohide: *mut nsAtom; + #[link_name = "\x01?norolluponanchor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_norolluponanchor: *mut nsAtom; + #[link_name = "\x01?nobr@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nobr: *mut nsAtom; + #[link_name = "\x01?node@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_node: *mut nsAtom; + #[link_name = "\x01?nodefaultsrc@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nodefaultsrc: *mut nsAtom; + #[link_name = "\x01?nodeSet@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nodeSet: *mut nsAtom; + #[link_name = "\x01?noembed@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_noembed: *mut nsAtom; + #[link_name = "\x01?noframes@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_noframes: *mut nsAtom; + #[link_name = "\x01?nohref@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nohref: *mut nsAtom; + #[link_name = "\x01?noisolation@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_noisolation: *mut nsAtom; + #[link_name = "\x01?nomodule@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nomodule: *mut nsAtom; + #[link_name = "\x01?nonce@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nonce: *mut nsAtom; + #[link_name = "\x01?none@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_none: *mut nsAtom; + #[link_name = "\x01?noresize@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_noresize: *mut nsAtom; + #[link_name = "\x01?normal@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_normal: *mut nsAtom; + #[link_name = "\x01?normalizeSpace@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_normalizeSpace: *mut nsAtom; + #[link_name = "\x01?noscript@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_noscript: *mut nsAtom; + #[link_name = "\x01?noshade@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_noshade: *mut nsAtom; + #[link_name = "\x01?novalidate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_novalidate: *mut nsAtom; + #[link_name = "\x01?_not@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__not: *mut nsAtom; + #[link_name = "\x01?nowrap@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nowrap: *mut nsAtom; + #[link_name = "\x01?number@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_number: *mut nsAtom; + #[link_name = "\x01?null@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_null: *mut nsAtom; + #[link_name = "\x01?object@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_object: *mut nsAtom; + #[link_name = "\x01?objectType@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_objectType: *mut nsAtom; + #[link_name = "\x01?observer@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_observer: *mut nsAtom; + #[link_name = "\x01?observes@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_observes: *mut nsAtom; + #[link_name = "\x01?odd@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_odd: *mut nsAtom; + #[link_name = "\x01?OFF@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_OFF: *mut nsAtom; + #[link_name = "\x01?ol@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ol: *mut nsAtom; + #[link_name = "\x01?omitXmlDeclaration@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_omitXmlDeclaration: *mut nsAtom; + #[link_name = "\x01?ona2dpstatuschanged@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ona2dpstatuschanged: *mut nsAtom; + #[link_name = "\x01?onabort@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onabort: *mut nsAtom; + #[link_name = "\x01?onmozaccesskeynotfound@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmozaccesskeynotfound: *mut nsAtom; + #[link_name = "\x01?onactivate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onactivate: *mut nsAtom; + #[link_name = "\x01?onadapteradded@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onadapteradded: *mut nsAtom; + #[link_name = "\x01?onadapterremoved@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onadapterremoved: *mut nsAtom; + #[link_name = "\x01?onafterprint@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onafterprint: *mut nsAtom; + #[link_name = "\x01?onafterscriptexecute@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onafterscriptexecute: *mut nsAtom; + #[link_name = "\x01?onalerting@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onalerting: *mut nsAtom; + #[link_name = "\x01?onanimationcancel@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onanimationcancel: *mut nsAtom; + #[link_name = "\x01?onanimationend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onanimationend: *mut nsAtom; + #[link_name = "\x01?onanimationiteration@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onanimationiteration: *mut nsAtom; + #[link_name = "\x01?onanimationstart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onanimationstart: *mut nsAtom; + #[link_name = "\x01?onantennaavailablechange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onantennaavailablechange: *mut nsAtom; + #[link_name = "\x01?onAppCommand@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onAppCommand: *mut nsAtom; + #[link_name = "\x01?onappinstalled@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onappinstalled: *mut nsAtom; + #[link_name = "\x01?onattributechanged@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onattributechanged: *mut nsAtom; + #[link_name = "\x01?onattributereadreq@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onattributereadreq: *mut nsAtom; + #[link_name = "\x01?onattributewritereq@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onattributewritereq: *mut nsAtom; + #[link_name = "\x01?onaudioprocess@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onaudioprocess: *mut nsAtom; + #[link_name = "\x01?onauxclick@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onauxclick: *mut nsAtom; + #[link_name = "\x01?onbeforecopy@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onbeforecopy: *mut nsAtom; + #[link_name = "\x01?onbeforecut@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onbeforecut: *mut nsAtom; + #[link_name = "\x01?onbeforepaste@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onbeforepaste: *mut nsAtom; + #[link_name = "\x01?onbeforeevicted@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onbeforeevicted: *mut nsAtom; + #[link_name = "\x01?onbeforeprint@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onbeforeprint: *mut nsAtom; + #[link_name = "\x01?onbeforescriptexecute@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onbeforescriptexecute: *mut nsAtom; + #[link_name = "\x01?onbeforeunload@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onbeforeunload: *mut nsAtom; + #[link_name = "\x01?onblocked@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onblocked: *mut nsAtom; + #[link_name = "\x01?onblur@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onblur: *mut nsAtom; + #[link_name = "\x01?onbroadcast@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onbroadcast: *mut nsAtom; + #[link_name = "\x01?onbusy@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onbusy: *mut nsAtom; + #[link_name = "\x01?onbufferedamountlow@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onbufferedamountlow: *mut nsAtom; + #[link_name = "\x01?oncached@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncached: *mut nsAtom; + #[link_name = "\x01?oncallschanged@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncallschanged: *mut nsAtom; + #[link_name = "\x01?oncancel@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncancel: *mut nsAtom; + #[link_name = "\x01?oncardstatechange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncardstatechange: *mut nsAtom; + #[link_name = "\x01?oncfstatechange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncfstatechange: *mut nsAtom; + #[link_name = "\x01?onchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onchange: *mut nsAtom; + #[link_name = "\x01?oncharacteristicchanged@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncharacteristicchanged: *mut nsAtom; + #[link_name = "\x01?onchargingchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onchargingchange: *mut nsAtom; + #[link_name = "\x01?onchargingtimechange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onchargingtimechange: *mut nsAtom; + #[link_name = "\x01?onchecking@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onchecking: *mut nsAtom; + #[link_name = "\x01?onCheckboxStateChange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onCheckboxStateChange: *mut nsAtom; + #[link_name = "\x01?onclick@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onclick: *mut nsAtom; + #[link_name = "\x01?onclirmodechange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onclirmodechange: *mut nsAtom; + #[link_name = "\x01?onclose@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onclose: *mut nsAtom; + #[link_name = "\x01?oncommand@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncommand: *mut nsAtom; + #[link_name = "\x01?oncommandupdate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncommandupdate: *mut nsAtom; + #[link_name = "\x01?oncomplete@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncomplete: *mut nsAtom; + #[link_name = "\x01?oncompositionend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncompositionend: *mut nsAtom; + #[link_name = "\x01?oncompositionstart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncompositionstart: *mut nsAtom; + #[link_name = "\x01?oncompositionupdate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncompositionupdate: *mut nsAtom; + #[link_name = "\x01?onconnect@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onconnect: *mut nsAtom; + #[link_name = "\x01?onconnected@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onconnected: *mut nsAtom; + #[link_name = "\x01?onconnecting@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onconnecting: *mut nsAtom; + #[link_name = "\x01?onconnectionavailable@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onconnectionavailable: *mut nsAtom; + #[link_name = "\x01?onconnectionstatechanged@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onconnectionstatechanged: *mut nsAtom; + #[link_name = "\x01?oncontextmenu@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncontextmenu: *mut nsAtom; + #[link_name = "\x01?oncopy@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncopy: *mut nsAtom; + #[link_name = "\x01?oncurrentchannelchanged@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncurrentchannelchanged: *mut nsAtom; + #[link_name = "\x01?oncurrentsourcechanged@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncurrentsourcechanged: *mut nsAtom; + #[link_name = "\x01?oncut@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncut: *mut nsAtom; + #[link_name = "\x01?ondatachange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondatachange: *mut nsAtom; + #[link_name = "\x01?ondataerror@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondataerror: *mut nsAtom; + #[link_name = "\x01?ondblclick@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondblclick: *mut nsAtom; + #[link_name = "\x01?ondeleted@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondeleted: *mut nsAtom; + #[link_name = "\x01?ondeliverysuccess@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondeliverysuccess: *mut nsAtom; + #[link_name = "\x01?ondeliveryerror@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondeliveryerror: *mut nsAtom; + #[link_name = "\x01?ondevicefound@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondevicefound: *mut nsAtom; + #[link_name = "\x01?ondevicepaired@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondevicepaired: *mut nsAtom; + #[link_name = "\x01?ondeviceunpaired@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondeviceunpaired: *mut nsAtom; + #[link_name = "\x01?ondialing@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondialing: *mut nsAtom; + #[link_name = "\x01?ondisabled@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondisabled: *mut nsAtom; + #[link_name = "\x01?ondischargingtimechange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondischargingtimechange: *mut nsAtom; + #[link_name = "\x01?ondisconnect@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondisconnect: *mut nsAtom; + #[link_name = "\x01?ondisconnected@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondisconnected: *mut nsAtom; + #[link_name = "\x01?ondisconnecting@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondisconnecting: *mut nsAtom; + #[link_name = "\x01?ondisplaypasskeyreq@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondisplaypasskeyreq: *mut nsAtom; + #[link_name = "\x01?ondownloading@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondownloading: *mut nsAtom; + #[link_name = "\x01?onDOMActivate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onDOMActivate: *mut nsAtom; + #[link_name = "\x01?onDOMAttrModified@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onDOMAttrModified: *mut nsAtom; + #[link_name = "\x01?onDOMCharacterDataModified@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onDOMCharacterDataModified: *mut nsAtom; + #[link_name = "\x01?onDOMFocusIn@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onDOMFocusIn: *mut nsAtom; + #[link_name = "\x01?onDOMFocusOut@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onDOMFocusOut: *mut nsAtom; + #[link_name = "\x01?onDOMMouseScroll@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onDOMMouseScroll: *mut nsAtom; + #[link_name = "\x01?onDOMNodeInserted@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onDOMNodeInserted: *mut nsAtom; + #[link_name = "\x01?onDOMNodeInsertedIntoDocument@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onDOMNodeInsertedIntoDocument: *mut nsAtom; + #[link_name = "\x01?onDOMNodeRemoved@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onDOMNodeRemoved: *mut nsAtom; + #[link_name = "\x01?onDOMNodeRemovedFromDocument@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onDOMNodeRemovedFromDocument: *mut nsAtom; + #[link_name = "\x01?onDOMSubtreeModified@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onDOMSubtreeModified: *mut nsAtom; + #[link_name = "\x01?ondata@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondata: *mut nsAtom; + #[link_name = "\x01?ondrag@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondrag: *mut nsAtom; + #[link_name = "\x01?ondragdrop@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondragdrop: *mut nsAtom; + #[link_name = "\x01?ondragend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondragend: *mut nsAtom; + #[link_name = "\x01?ondragenter@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondragenter: *mut nsAtom; + #[link_name = "\x01?ondragexit@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondragexit: *mut nsAtom; + #[link_name = "\x01?ondraggesture@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondraggesture: *mut nsAtom; + #[link_name = "\x01?ondragleave@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondragleave: *mut nsAtom; + #[link_name = "\x01?ondragover@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondragover: *mut nsAtom; + #[link_name = "\x01?ondragstart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondragstart: *mut nsAtom; + #[link_name = "\x01?ondrain@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondrain: *mut nsAtom; + #[link_name = "\x01?ondrop@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondrop: *mut nsAtom; + #[link_name = "\x01?oneitbroadcasted@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oneitbroadcasted: *mut nsAtom; + #[link_name = "\x01?onenabled@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onenabled: *mut nsAtom; + #[link_name = "\x01?onenterpincodereq@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onenterpincodereq: *mut nsAtom; + #[link_name = "\x01?onemergencycbmodechange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onemergencycbmodechange: *mut nsAtom; + #[link_name = "\x01?onerror@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onerror: *mut nsAtom; + #[link_name = "\x01?onevicted@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onevicted: *mut nsAtom; + #[link_name = "\x01?onfailed@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onfailed: *mut nsAtom; + #[link_name = "\x01?onfetch@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onfetch: *mut nsAtom; + #[link_name = "\x01?onfinish@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onfinish: *mut nsAtom; + #[link_name = "\x01?onfocus@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onfocus: *mut nsAtom; + #[link_name = "\x01?onfocusin@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onfocusin: *mut nsAtom; + #[link_name = "\x01?onfocusout@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onfocusout: *mut nsAtom; + #[link_name = "\x01?onfrequencychange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onfrequencychange: *mut nsAtom; + #[link_name = "\x01?onfullscreenchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onfullscreenchange: *mut nsAtom; + #[link_name = "\x01?onfullscreenerror@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onfullscreenerror: *mut nsAtom; + #[link_name = "\x01?onspeakerforcedchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onspeakerforcedchange: *mut nsAtom; + #[link_name = "\x01?onget@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onget: *mut nsAtom; + #[link_name = "\x01?ongroupchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ongroupchange: *mut nsAtom; + #[link_name = "\x01?onhashchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onhashchange: *mut nsAtom; + #[link_name = "\x01?onheadphoneschange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onheadphoneschange: *mut nsAtom; + #[link_name = "\x01?onheld@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onheld: *mut nsAtom; + #[link_name = "\x01?onhfpstatuschanged@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onhfpstatuschanged: *mut nsAtom; + #[link_name = "\x01?onhidstatuschanged@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onhidstatuschanged: *mut nsAtom; + #[link_name = "\x01?onholding@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onholding: *mut nsAtom; + #[link_name = "\x01?oniccchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oniccchange: *mut nsAtom; + #[link_name = "\x01?oniccdetected@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oniccdetected: *mut nsAtom; + #[link_name = "\x01?oniccinfochange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oniccinfochange: *mut nsAtom; + #[link_name = "\x01?oniccundetected@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oniccundetected: *mut nsAtom; + #[link_name = "\x01?onincoming@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onincoming: *mut nsAtom; + #[link_name = "\x01?oninput@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oninput: *mut nsAtom; + #[link_name = "\x01?oninstall@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oninstall: *mut nsAtom; + #[link_name = "\x01?oninvalid@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oninvalid: *mut nsAtom; + #[link_name = "\x01?onkeydown@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onkeydown: *mut nsAtom; + #[link_name = "\x01?onkeypress@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onkeypress: *mut nsAtom; + #[link_name = "\x01?onkeyup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onkeyup: *mut nsAtom; + #[link_name = "\x01?onlanguagechange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onlanguagechange: *mut nsAtom; + #[link_name = "\x01?onlevelchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onlevelchange: *mut nsAtom; + #[link_name = "\x01?onLoad@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onLoad: *mut nsAtom; + #[link_name = "\x01?onload@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onload: *mut nsAtom; + #[link_name = "\x01?onloading@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onloading: *mut nsAtom; + #[link_name = "\x01?onloadingdone@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onloadingdone: *mut nsAtom; + #[link_name = "\x01?onloadingerror@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onloadingerror: *mut nsAtom; + #[link_name = "\x01?onpopstate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpopstate: *mut nsAtom; + #[link_name = "\x01?only@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_only: *mut nsAtom; + #[link_name = "\x01?onmessage@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmessage: *mut nsAtom; + #[link_name = "\x01?onmessageerror@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmessageerror: *mut nsAtom; + #[link_name = "\x01?onmousedown@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmousedown: *mut nsAtom; + #[link_name = "\x01?onmouseenter@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmouseenter: *mut nsAtom; + #[link_name = "\x01?onmouseleave@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmouseleave: *mut nsAtom; + #[link_name = "\x01?onmouselongtap@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmouselongtap: *mut nsAtom; + #[link_name = "\x01?onmousemove@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmousemove: *mut nsAtom; + #[link_name = "\x01?onmouseout@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmouseout: *mut nsAtom; + #[link_name = "\x01?onmouseover@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmouseover: *mut nsAtom; + #[link_name = "\x01?onMozMouseHittest@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onMozMouseHittest: *mut nsAtom; + #[link_name = "\x01?onmouseup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmouseup: *mut nsAtom; + #[link_name = "\x01?onMozAfterPaint@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onMozAfterPaint: *mut nsAtom; + #[link_name = "\x01?onmozfullscreenchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmozfullscreenchange: *mut nsAtom; + #[link_name = "\x01?onmozfullscreenerror@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmozfullscreenerror: *mut nsAtom; + #[link_name = "\x01?onmozkeydownonplugin@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmozkeydownonplugin: *mut nsAtom; + #[link_name = "\x01?onmozkeyuponplugin@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmozkeyuponplugin: *mut nsAtom; + #[link_name = "\x01?onmozpointerlockchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmozpointerlockchange: *mut nsAtom; + #[link_name = "\x01?onmozpointerlockerror@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmozpointerlockerror: *mut nsAtom; + #[link_name = "\x01?onMozMousePixelScroll@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onMozMousePixelScroll: *mut nsAtom; + #[link_name = "\x01?onMozScrolledAreaChanged@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onMozScrolledAreaChanged: *mut nsAtom; + #[link_name = "\x01?onmapfolderlistingreq@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmapfolderlistingreq: *mut nsAtom; + #[link_name = "\x01?onmapmessageslistingreq@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmapmessageslistingreq: *mut nsAtom; + #[link_name = "\x01?onmapgetmessagereq@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmapgetmessagereq: *mut nsAtom; + #[link_name = "\x01?onmapsetmessagestatusreq@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmapsetmessagestatusreq: *mut nsAtom; + #[link_name = "\x01?onmapsendmessagereq@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmapsendmessagereq: *mut nsAtom; + #[link_name = "\x01?onmapmessageupdatereq@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmapmessageupdatereq: *mut nsAtom; + #[link_name = "\x01?onnewrdsgroup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onnewrdsgroup: *mut nsAtom; + #[link_name = "\x01?onnotificationclick@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onnotificationclick: *mut nsAtom; + #[link_name = "\x01?onnotificationclose@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onnotificationclose: *mut nsAtom; + #[link_name = "\x01?onnoupdate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onnoupdate: *mut nsAtom; + #[link_name = "\x01?onobexpasswordreq@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onobexpasswordreq: *mut nsAtom; + #[link_name = "\x01?onobsolete@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onobsolete: *mut nsAtom; + #[link_name = "\x01?ononline@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ononline: *mut nsAtom; + #[link_name = "\x01?onoffline@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onoffline: *mut nsAtom; + #[link_name = "\x01?onopen@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onopen: *mut nsAtom; + #[link_name = "\x01?onorientationchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onorientationchange: *mut nsAtom; + #[link_name = "\x01?onotastatuschange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onotastatuschange: *mut nsAtom; + #[link_name = "\x01?onoverflow@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onoverflow: *mut nsAtom; + #[link_name = "\x01?onoverflowchanged@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onoverflowchanged: *mut nsAtom; + #[link_name = "\x01?onpagehide@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpagehide: *mut nsAtom; + #[link_name = "\x01?onpageshow@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpageshow: *mut nsAtom; + #[link_name = "\x01?onpaint@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpaint: *mut nsAtom; + #[link_name = "\x01?onpairingaborted@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpairingaborted: *mut nsAtom; + #[link_name = "\x01?onpairingconfirmationreq@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpairingconfirmationreq: *mut nsAtom; + #[link_name = "\x01?onpairingconsentreq@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpairingconsentreq: *mut nsAtom; + #[link_name = "\x01?onpaste@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpaste: *mut nsAtom; + #[link_name = "\x01?onpendingchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpendingchange: *mut nsAtom; + #[link_name = "\x01?onpichange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpichange: *mut nsAtom; + #[link_name = "\x01?onpointerlockchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpointerlockchange: *mut nsAtom; + #[link_name = "\x01?onpointerlockerror@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpointerlockerror: *mut nsAtom; + #[link_name = "\x01?onpopuphidden@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpopuphidden: *mut nsAtom; + #[link_name = "\x01?onpopuphiding@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpopuphiding: *mut nsAtom; + #[link_name = "\x01?onpopuppositioned@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpopuppositioned: *mut nsAtom; + #[link_name = "\x01?onpopupshowing@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpopupshowing: *mut nsAtom; + #[link_name = "\x01?onpopupshown@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpopupshown: *mut nsAtom; + #[link_name = "\x01?onpullphonebookreq@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpullphonebookreq: *mut nsAtom; + #[link_name = "\x01?onpullvcardentryreq@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpullvcardentryreq: *mut nsAtom; + #[link_name = "\x01?onpullvcardlistingreq@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpullvcardlistingreq: *mut nsAtom; + #[link_name = "\x01?onpush@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpush: *mut nsAtom; + #[link_name = "\x01?onpushsubscriptionchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpushsubscriptionchange: *mut nsAtom; + #[link_name = "\x01?onpschange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpschange: *mut nsAtom; + #[link_name = "\x01?onptychange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onptychange: *mut nsAtom; + #[link_name = "\x01?onradiostatechange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onradiostatechange: *mut nsAtom; + #[link_name = "\x01?onRadioStateChange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onRadioStateChange: *mut nsAtom; + #[link_name = "\x01?onrdsdisabled@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onrdsdisabled: *mut nsAtom; + #[link_name = "\x01?onrdsenabled@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onrdsenabled: *mut nsAtom; + #[link_name = "\x01?onreaderror@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onreaderror: *mut nsAtom; + #[link_name = "\x01?onreadsuccess@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onreadsuccess: *mut nsAtom; + #[link_name = "\x01?onready@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onready: *mut nsAtom; + #[link_name = "\x01?onreadystatechange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onreadystatechange: *mut nsAtom; + #[link_name = "\x01?onreceived@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onreceived: *mut nsAtom; + #[link_name = "\x01?onremoteheld@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onremoteheld: *mut nsAtom; + #[link_name = "\x01?onremoteresumed@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onremoteresumed: *mut nsAtom; + #[link_name = "\x01?onrequestprogress@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onrequestprogress: *mut nsAtom; + #[link_name = "\x01?onresourcetimingbufferfull@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onresourcetimingbufferfull: *mut nsAtom; + #[link_name = "\x01?onresponseprogress@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onresponseprogress: *mut nsAtom; + #[link_name = "\x01?onretrieving@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onretrieving: *mut nsAtom; + #[link_name = "\x01?onRequest@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onRequest: *mut nsAtom; + #[link_name = "\x01?onrequestmediaplaystatus@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onrequestmediaplaystatus: *mut nsAtom; + #[link_name = "\x01?onreset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onreset: *mut nsAtom; + #[link_name = "\x01?onresuming@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onresuming: *mut nsAtom; + #[link_name = "\x01?onresize@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onresize: *mut nsAtom; + #[link_name = "\x01?onrtchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onrtchange: *mut nsAtom; + #[link_name = "\x01?onscanningstatechanged@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onscanningstatechanged: *mut nsAtom; + #[link_name = "\x01?onscostatuschanged@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onscostatuschanged: *mut nsAtom; + #[link_name = "\x01?onscroll@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onscroll: *mut nsAtom; + #[link_name = "\x01?onselect@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onselect: *mut nsAtom; + #[link_name = "\x01?onselectionchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onselectionchange: *mut nsAtom; + #[link_name = "\x01?onselectstart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onselectstart: *mut nsAtom; + #[link_name = "\x01?onsending@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onsending: *mut nsAtom; + #[link_name = "\x01?onsent@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onsent: *mut nsAtom; + #[link_name = "\x01?onset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onset: *mut nsAtom; + #[link_name = "\x01?onshippingaddresschange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onshippingaddresschange: *mut nsAtom; + #[link_name = "\x01?onshippingoptionchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onshippingoptionchange: *mut nsAtom; + #[link_name = "\x01?onshow@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onshow: *mut nsAtom; + #[link_name = "\x01?onstatechange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onstatechange: *mut nsAtom; + #[link_name = "\x01?onstatuschanged@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onstatuschanged: *mut nsAtom; + #[link_name = "\x01?onstkcommand@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onstkcommand: *mut nsAtom; + #[link_name = "\x01?onstksessionend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onstksessionend: *mut nsAtom; + #[link_name = "\x01?onstorage@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onstorage: *mut nsAtom; + #[link_name = "\x01?onstorageareachanged@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onstorageareachanged: *mut nsAtom; + #[link_name = "\x01?onsubmit@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onsubmit: *mut nsAtom; + #[link_name = "\x01?onsuccess@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onsuccess: *mut nsAtom; + #[link_name = "\x01?ontypechange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ontypechange: *mut nsAtom; + #[link_name = "\x01?onterminate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onterminate: *mut nsAtom; + #[link_name = "\x01?ontext@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ontext: *mut nsAtom; + #[link_name = "\x01?ontoggle@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ontoggle: *mut nsAtom; + #[link_name = "\x01?ontouchstart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ontouchstart: *mut nsAtom; + #[link_name = "\x01?ontouchend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ontouchend: *mut nsAtom; + #[link_name = "\x01?ontouchmove@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ontouchmove: *mut nsAtom; + #[link_name = "\x01?ontouchcancel@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ontouchcancel: *mut nsAtom; + #[link_name = "\x01?ontransitioncancel@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ontransitioncancel: *mut nsAtom; + #[link_name = "\x01?ontransitionend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ontransitionend: *mut nsAtom; + #[link_name = "\x01?ontransitionrun@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ontransitionrun: *mut nsAtom; + #[link_name = "\x01?ontransitionstart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ontransitionstart: *mut nsAtom; + #[link_name = "\x01?onunderflow@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onunderflow: *mut nsAtom; + #[link_name = "\x01?onunload@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onunload: *mut nsAtom; + #[link_name = "\x01?onupdatefound@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onupdatefound: *mut nsAtom; + #[link_name = "\x01?onupdateready@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onupdateready: *mut nsAtom; + #[link_name = "\x01?onupgradeneeded@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onupgradeneeded: *mut nsAtom; + #[link_name = "\x01?onussdreceived@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onussdreceived: *mut nsAtom; + #[link_name = "\x01?onversionchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onversionchange: *mut nsAtom; + #[link_name = "\x01?onvisibilitychange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onvisibilitychange: *mut nsAtom; + #[link_name = "\x01?onvoicechange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onvoicechange: *mut nsAtom; + #[link_name = "\x01?onvoiceschanged@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onvoiceschanged: *mut nsAtom; + #[link_name = "\x01?onvrdisplayactivate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onvrdisplayactivate: *mut nsAtom; + #[link_name = "\x01?onvrdisplayconnect@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onvrdisplayconnect: *mut nsAtom; + #[link_name = "\x01?onvrdisplaydeactivate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onvrdisplaydeactivate: *mut nsAtom; + #[link_name = "\x01?onvrdisplaydisconnect@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onvrdisplaydisconnect: *mut nsAtom; + #[link_name = "\x01?onvrdisplaypresentchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onvrdisplaypresentchange: *mut nsAtom; + #[link_name = "\x01?onwebkitAnimationEnd@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onwebkitAnimationEnd: *mut nsAtom; + #[link_name = "\x01?onwebkitAnimationIteration@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onwebkitAnimationIteration: *mut nsAtom; + #[link_name = "\x01?onwebkitAnimationStart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onwebkitAnimationStart: *mut nsAtom; + #[link_name = "\x01?onwebkitTransitionEnd@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onwebkitTransitionEnd: *mut nsAtom; + #[link_name = "\x01?onwebkitanimationend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onwebkitanimationend: *mut nsAtom; + #[link_name = "\x01?onwebkitanimationiteration@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onwebkitanimationiteration: *mut nsAtom; + #[link_name = "\x01?onwebkitanimationstart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onwebkitanimationstart: *mut nsAtom; + #[link_name = "\x01?onwebkittransitionend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onwebkittransitionend: *mut nsAtom; + #[link_name = "\x01?onwebsocket@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onwebsocket: *mut nsAtom; + #[link_name = "\x01?onwheel@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onwheel: *mut nsAtom; + #[link_name = "\x01?open@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_open: *mut nsAtom; + #[link_name = "\x01?optgroup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_optgroup: *mut nsAtom; + #[link_name = "\x01?optimum@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_optimum: *mut nsAtom; + #[link_name = "\x01?option@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_option: *mut nsAtom; + #[link_name = "\x01?_or@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__or: *mut nsAtom; + #[link_name = "\x01?order@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_order: *mut nsAtom; + #[link_name = "\x01?ordinal@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ordinal: *mut nsAtom; + #[link_name = "\x01?orient@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_orient: *mut nsAtom; + #[link_name = "\x01?orientation@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_orientation: *mut nsAtom; + #[link_name = "\x01?otherwise@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_otherwise: *mut nsAtom; + #[link_name = "\x01?output@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_output: *mut nsAtom; + #[link_name = "\x01?overflow@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_overflow: *mut nsAtom; + #[link_name = "\x01?overflowchanged@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_overflowchanged: *mut nsAtom; + #[link_name = "\x01?overlay@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_overlay: *mut nsAtom; + #[link_name = "\x01?overlap@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_overlap: *mut nsAtom; + #[link_name = "\x01?p@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_p: *mut nsAtom; + #[link_name = "\x01?pack@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pack: *mut nsAtom; + #[link_name = "\x01?page@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_page: *mut nsAtom; + #[link_name = "\x01?pageincrement@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pageincrement: *mut nsAtom; + #[link_name = "\x01?pagex@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pagex: *mut nsAtom; + #[link_name = "\x01?pagey@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pagey: *mut nsAtom; + #[link_name = "\x01?paint_order@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_paint_order: *mut nsAtom; + #[link_name = "\x01?palettename@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_palettename: *mut nsAtom; + #[link_name = "\x01?panel@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_panel: *mut nsAtom; + #[link_name = "\x01?param@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_param: *mut nsAtom; + #[link_name = "\x01?parameter@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_parameter: *mut nsAtom; + #[link_name = "\x01?parent@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_parent: *mut nsAtom; + #[link_name = "\x01?parentfocused@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_parentfocused: *mut nsAtom; + #[link_name = "\x01?parsetype@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_parsetype: *mut nsAtom; + #[link_name = "\x01?password@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_password: *mut nsAtom; + #[link_name = "\x01?pattern@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pattern: *mut nsAtom; + #[link_name = "\x01?patternSeparator@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_patternSeparator: *mut nsAtom; + #[link_name = "\x01?perMille@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_perMille: *mut nsAtom; + #[link_name = "\x01?percent@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_percent: *mut nsAtom; + #[link_name = "\x01?persist@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_persist: *mut nsAtom; + #[link_name = "\x01?phase@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_phase: *mut nsAtom; + #[link_name = "\x01?picture@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_picture: *mut nsAtom; + #[link_name = "\x01?ping@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ping: *mut nsAtom; + #[link_name = "\x01?pinned@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pinned: *mut nsAtom; + #[link_name = "\x01?placeholder@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_placeholder: *mut nsAtom; + #[link_name = "\x01?plaintext@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_plaintext: *mut nsAtom; + #[link_name = "\x01?playbackrate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_playbackrate: *mut nsAtom; + #[link_name = "\x01?pointSize@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pointSize: *mut nsAtom; + #[link_name = "\x01?pointerlockchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pointerlockchange: *mut nsAtom; + #[link_name = "\x01?pointerlockerror@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pointerlockerror: *mut nsAtom; + #[link_name = "\x01?poly@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_poly: *mut nsAtom; + #[link_name = "\x01?polygon@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_polygon: *mut nsAtom; + #[link_name = "\x01?popup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_popup: *mut nsAtom; + #[link_name = "\x01?popupalign@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_popupalign: *mut nsAtom; + #[link_name = "\x01?popupanchor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_popupanchor: *mut nsAtom; + #[link_name = "\x01?popupgroup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_popupgroup: *mut nsAtom; + #[link_name = "\x01?popuphidden@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_popuphidden: *mut nsAtom; + #[link_name = "\x01?popuphiding@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_popuphiding: *mut nsAtom; + #[link_name = "\x01?popupset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_popupset: *mut nsAtom; + #[link_name = "\x01?popupshowing@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_popupshowing: *mut nsAtom; + #[link_name = "\x01?popupshown@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_popupshown: *mut nsAtom; + #[link_name = "\x01?popupsinherittooltip@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_popupsinherittooltip: *mut nsAtom; + #[link_name = "\x01?position@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_position: *mut nsAtom; + #[link_name = "\x01?poster@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_poster: *mut nsAtom; + #[link_name = "\x01?pre@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pre: *mut nsAtom; + #[link_name = "\x01?preceding@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_preceding: *mut nsAtom; + #[link_name = "\x01?precedingSibling@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_precedingSibling: *mut nsAtom; + #[link_name = "\x01?predicate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_predicate: *mut nsAtom; + #[link_name = "\x01?prefix@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_prefix: *mut nsAtom; + #[link_name = "\x01?preload@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_preload: *mut nsAtom; + #[link_name = "\x01?prerendered@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_prerendered: *mut nsAtom; + #[link_name = "\x01?mozpresentation@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozpresentation: *mut nsAtom; + #[link_name = "\x01?preserve@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_preserve: *mut nsAtom; + #[link_name = "\x01?preserveSpace@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_preserveSpace: *mut nsAtom; + #[link_name = "\x01?preventdefault@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_preventdefault: *mut nsAtom; + #[link_name = "\x01?primary@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_primary: *mut nsAtom; + #[link_name = "\x01?print@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_print: *mut nsAtom; + #[link_name = "\x01?priority@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_priority: *mut nsAtom; + #[link_name = "\x01?processingInstruction@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_processingInstruction: *mut nsAtom; + #[link_name = "\x01?profile@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_profile: *mut nsAtom; + #[link_name = "\x01?progress@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_progress: *mut nsAtom; + #[link_name = "\x01?progressmeter@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_progressmeter: *mut nsAtom; + #[link_name = "\x01?progressNormal@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_progressNormal: *mut nsAtom; + #[link_name = "\x01?progressUndetermined@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_progressUndetermined: *mut nsAtom; + #[link_name = "\x01?projection@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_projection: *mut nsAtom; + #[link_name = "\x01?prompt@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_prompt: *mut nsAtom; + #[link_name = "\x01?propagate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_propagate: *mut nsAtom; + #[link_name = "\x01?properties@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_properties: *mut nsAtom; + #[link_name = "\x01?property@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_property: *mut nsAtom; + #[link_name = "\x01?pubdate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pubdate: *mut nsAtom; + #[link_name = "\x01?q@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_q: *mut nsAtom; + #[link_name = "\x01?query@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_query: *mut nsAtom; + #[link_name = "\x01?queryset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_queryset: *mut nsAtom; + #[link_name = "\x01?querytype@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_querytype: *mut nsAtom; + #[link_name = "\x01?radio@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_radio: *mut nsAtom; + #[link_name = "\x01?radiogroup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_radiogroup: *mut nsAtom; + #[link_name = "\x01?range@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_range: *mut nsAtom; + #[link_name = "\x01?readonly@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_readonly: *mut nsAtom; + #[link_name = "\x01?rect@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rect: *mut nsAtom; + #[link_name = "\x01?rectangle@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rectangle: *mut nsAtom; + #[link_name = "\x01?ref@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ref: *mut nsAtom; + #[link_name = "\x01?refresh@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_refresh: *mut nsAtom; + #[link_name = "\x01?rel@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rel: *mut nsAtom; + #[link_name = "\x01?onreloadpage@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onreloadpage: *mut nsAtom; + #[link_name = "\x01?rem@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rem: *mut nsAtom; + #[link_name = "\x01?remote@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_remote: *mut nsAtom; + #[link_name = "\x01?removeelement@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_removeelement: *mut nsAtom; + #[link_name = "\x01?renderingobserverlist@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_renderingobserverlist: *mut nsAtom; + #[link_name = "\x01?repeat@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_repeat: *mut nsAtom; + #[link_name = "\x01?replace@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_replace: *mut nsAtom; + #[link_name = "\x01?requestcontextid@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_requestcontextid: *mut nsAtom; + #[link_name = "\x01?required@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_required: *mut nsAtom; + #[link_name = "\x01?reserved@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_reserved: *mut nsAtom; + #[link_name = "\x01?reset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_reset: *mut nsAtom; + #[link_name = "\x01?resizeafter@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_resizeafter: *mut nsAtom; + #[link_name = "\x01?resizebefore@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_resizebefore: *mut nsAtom; + #[link_name = "\x01?resizer@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_resizer: *mut nsAtom; + #[link_name = "\x01?resolution@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_resolution: *mut nsAtom; + #[link_name = "\x01?resource@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_resource: *mut nsAtom; + #[link_name = "\x01?resources@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_resources: *mut nsAtom; + #[link_name = "\x01?result@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_result: *mut nsAtom; + #[link_name = "\x01?resultPrefix@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_resultPrefix: *mut nsAtom; + #[link_name = "\x01?retargetdocumentfocus@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_retargetdocumentfocus: *mut nsAtom; + #[link_name = "\x01?rev@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rev: *mut nsAtom; + #[link_name = "\x01?reverse@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_reverse: *mut nsAtom; + #[link_name = "\x01?reversed@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_reversed: *mut nsAtom; + #[link_name = "\x01?richlistbox@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_richlistbox: *mut nsAtom; + #[link_name = "\x01?richlistitem@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_richlistitem: *mut nsAtom; + #[link_name = "\x01?right@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_right: *mut nsAtom; + #[link_name = "\x01?rightmargin@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rightmargin: *mut nsAtom; + #[link_name = "\x01?rightpadding@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rightpadding: *mut nsAtom; + #[link_name = "\x01?role@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_role: *mut nsAtom; + #[link_name = "\x01?rolluponmousewheel@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rolluponmousewheel: *mut nsAtom; + #[link_name = "\x01?round@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_round: *mut nsAtom; + #[link_name = "\x01?row@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_row: *mut nsAtom; + #[link_name = "\x01?rows@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rows: *mut nsAtom; + #[link_name = "\x01?rowspan@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rowspan: *mut nsAtom; + #[link_name = "\x01?rb@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rb: *mut nsAtom; + #[link_name = "\x01?rp@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rp: *mut nsAtom; + #[link_name = "\x01?rt@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rt: *mut nsAtom; + #[link_name = "\x01?rtc@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rtc: *mut nsAtom; + #[link_name = "\x01?rtl@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rtl: *mut nsAtom; + #[link_name = "\x01?ruby@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ruby: *mut nsAtom; + #[link_name = "\x01?rubyBase@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rubyBase: *mut nsAtom; + #[link_name = "\x01?rubyBaseContainer@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rubyBaseContainer: *mut nsAtom; + #[link_name = "\x01?rubyText@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rubyText: *mut nsAtom; + #[link_name = "\x01?rubyTextContainer@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rubyTextContainer: *mut nsAtom; + #[link_name = "\x01?rule@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rule: *mut nsAtom; + #[link_name = "\x01?rules@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rules: *mut nsAtom; + #[link_name = "\x01?s@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_s: *mut nsAtom; + #[link_name = "\x01?samp@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_samp: *mut nsAtom; + #[link_name = "\x01?sandbox@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sandbox: *mut nsAtom; + #[link_name = "\x01?sbattr@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sbattr: *mut nsAtom; + #[link_name = "\x01?scale@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scale: *mut nsAtom; + #[link_name = "\x01?scan@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scan: *mut nsAtom; + #[link_name = "\x01?scheme@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scheme: *mut nsAtom; + #[link_name = "\x01?scope@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scope: *mut nsAtom; + #[link_name = "\x01?scoped@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scoped: *mut nsAtom; + #[link_name = "\x01?screen@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_screen: *mut nsAtom; + #[link_name = "\x01?screenX@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_screenX: *mut nsAtom; + #[link_name = "\x01?screenY@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_screenY: *mut nsAtom; + #[link_name = "\x01?script@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_script: *mut nsAtom; + #[link_name = "\x01?scriptEnabledBeforePrintOrPreview@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scriptEnabledBeforePrintOrPreview: *mut nsAtom; + #[link_name = "\x01?scrollbar@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scrollbar: *mut nsAtom; + #[link_name = "\x01?scrollbarbutton@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scrollbarbutton: *mut nsAtom; + #[link_name = "\x01?scrollbarDownBottom@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scrollbarDownBottom: *mut nsAtom; + #[link_name = "\x01?scrollbarDownTop@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scrollbarDownTop: *mut nsAtom; + #[link_name = "\x01?scrollbarUpBottom@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scrollbarUpBottom: *mut nsAtom; + #[link_name = "\x01?scrollbarUpTop@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scrollbarUpTop: *mut nsAtom; + #[link_name = "\x01?scrollbox@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scrollbox: *mut nsAtom; + #[link_name = "\x01?scrollcorner@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scrollcorner: *mut nsAtom; + #[link_name = "\x01?scrolling@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scrolling: *mut nsAtom; + #[link_name = "\x01?scrollPosition@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scrollPosition: *mut nsAtom; + #[link_name = "\x01?section@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_section: *mut nsAtom; + #[link_name = "\x01?select@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_select: *mut nsAtom; + #[link_name = "\x01?selectable@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_selectable: *mut nsAtom; + #[link_name = "\x01?selected@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_selected: *mut nsAtom; + #[link_name = "\x01?selectedIndex@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_selectedIndex: *mut nsAtom; + #[link_name = "\x01?selectedindex@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_selectedindex: *mut nsAtom; + #[link_name = "\x01?self@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_self: *mut nsAtom; + #[link_name = "\x01?seltype@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_seltype: *mut nsAtom; + #[link_name = "\x01?setcookie@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_setcookie: *mut nsAtom; + #[link_name = "\x01?setter@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_setter: *mut nsAtom; + #[link_name = "\x01?shape@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_shape: *mut nsAtom; + #[link_name = "\x01?show@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_show: *mut nsAtom; + #[link_name = "\x01?showcaret@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_showcaret: *mut nsAtom; + #[link_name = "\x01?showresizer@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_showresizer: *mut nsAtom; + #[link_name = "\x01?simple@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_simple: *mut nsAtom; + #[link_name = "\x01?simp_chinese_formal@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_simp_chinese_formal: *mut nsAtom; + #[link_name = "\x01?simp_chinese_informal@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_simp_chinese_informal: *mut nsAtom; + #[link_name = "\x01?single@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_single: *mut nsAtom; + #[link_name = "\x01?size@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_size: *mut nsAtom; + #[link_name = "\x01?sizes@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sizes: *mut nsAtom; + #[link_name = "\x01?sizemode@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sizemode: *mut nsAtom; + #[link_name = "\x01?sizetopopup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sizetopopup: *mut nsAtom; + #[link_name = "\x01?slider@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_slider: *mut nsAtom; + #[link_name = "\x01?small@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_small: *mut nsAtom; + #[link_name = "\x01?smooth@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_smooth: *mut nsAtom; + #[link_name = "\x01?snap@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_snap: *mut nsAtom; + #[link_name = "\x01?sort@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sort: *mut nsAtom; + #[link_name = "\x01?sortActive@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sortActive: *mut nsAtom; + #[link_name = "\x01?sortDirection@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sortDirection: *mut nsAtom; + #[link_name = "\x01?sorted@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sorted: *mut nsAtom; + #[link_name = "\x01?sorthints@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sorthints: *mut nsAtom; + #[link_name = "\x01?sortLocked@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sortLocked: *mut nsAtom; + #[link_name = "\x01?sortResource@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sortResource: *mut nsAtom; + #[link_name = "\x01?sortResource2@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sortResource2: *mut nsAtom; + #[link_name = "\x01?sortSeparators@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sortSeparators: *mut nsAtom; + #[link_name = "\x01?sortStaticsLast@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sortStaticsLast: *mut nsAtom; + #[link_name = "\x01?source@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_source: *mut nsAtom; + #[link_name = "\x01?space@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_space: *mut nsAtom; + #[link_name = "\x01?spacer@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_spacer: *mut nsAtom; + #[link_name = "\x01?span@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_span: *mut nsAtom; + #[link_name = "\x01?spellcheck@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_spellcheck: *mut nsAtom; + #[link_name = "\x01?spinner@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_spinner: *mut nsAtom; + #[link_name = "\x01?split@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_split: *mut nsAtom; + #[link_name = "\x01?splitter@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_splitter: *mut nsAtom; + #[link_name = "\x01?spring@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_spring: *mut nsAtom; + #[link_name = "\x01?square@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_square: *mut nsAtom; + #[link_name = "\x01?src@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_src: *mut nsAtom; + #[link_name = "\x01?srcdoc@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_srcdoc: *mut nsAtom; + #[link_name = "\x01?srclang@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_srclang: *mut nsAtom; + #[link_name = "\x01?srcset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_srcset: *mut nsAtom; + #[link_name = "\x01?stack@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stack: *mut nsAtom; + #[link_name = "\x01?standalone@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_standalone: *mut nsAtom; + #[link_name = "\x01?standby@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_standby: *mut nsAtom; + #[link_name = "\x01?start@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_start: *mut nsAtom; + #[link_name = "\x01?start_after@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_start_after: *mut nsAtom; + #[link_name = "\x01?start_before@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_start_before: *mut nsAtom; + #[link_name = "\x01?startsWith@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_startsWith: *mut nsAtom; + #[link_name = "\x01?state@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_state: *mut nsAtom; + #[link_name = "\x01?statedatasource@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_statedatasource: *mut nsAtom; + #[link_name = "\x01?staticHint@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_staticHint: *mut nsAtom; + #[link_name = "\x01?statusbar@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_statusbar: *mut nsAtom; + #[link_name = "\x01?statustext@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_statustext: *mut nsAtom; + #[link_name = "\x01?step@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_step: *mut nsAtom; + #[link_name = "\x01?stop@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stop: *mut nsAtom; + #[link_name = "\x01?stretch@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stretch: *mut nsAtom; + #[link_name = "\x01?strike@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_strike: *mut nsAtom; + #[link_name = "\x01?string@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_string: *mut nsAtom; + #[link_name = "\x01?stringLength@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stringLength: *mut nsAtom; + #[link_name = "\x01?stripSpace@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stripSpace: *mut nsAtom; + #[link_name = "\x01?strong@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_strong: *mut nsAtom; + #[link_name = "\x01?style@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_style: *mut nsAtom; + #[link_name = "\x01?stylesheet@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stylesheet: *mut nsAtom; + #[link_name = "\x01?stylesheetPrefix@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stylesheetPrefix: *mut nsAtom; + #[link_name = "\x01?subject@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_subject: *mut nsAtom; + #[link_name = "\x01?submit@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_submit: *mut nsAtom; + #[link_name = "\x01?substate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_substate: *mut nsAtom; + #[link_name = "\x01?substring@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_substring: *mut nsAtom; + #[link_name = "\x01?substringAfter@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_substringAfter: *mut nsAtom; + #[link_name = "\x01?substringBefore@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_substringBefore: *mut nsAtom; + #[link_name = "\x01?sub@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sub: *mut nsAtom; + #[link_name = "\x01?sum@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sum: *mut nsAtom; + #[link_name = "\x01?sup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sup: *mut nsAtom; + #[link_name = "\x01?summary@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_summary: *mut nsAtom; + #[link_name = "\x01?_switch@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__switch: *mut nsAtom; + #[link_name = "\x01?systemProperty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_systemProperty: *mut nsAtom; + #[link_name = "\x01?tab@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tab: *mut nsAtom; + #[link_name = "\x01?tabbox@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tabbox: *mut nsAtom; + #[link_name = "\x01?tabindex@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tabindex: *mut nsAtom; + #[link_name = "\x01?table@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_table: *mut nsAtom; + #[link_name = "\x01?tabpanel@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tabpanel: *mut nsAtom; + #[link_name = "\x01?tabpanels@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tabpanels: *mut nsAtom; + #[link_name = "\x01?tag@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tag: *mut nsAtom; + #[link_name = "\x01?target@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_target: *mut nsAtom; + #[link_name = "\x01?targets@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_targets: *mut nsAtom; + #[link_name = "\x01?tbody@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tbody: *mut nsAtom; + #[link_name = "\x01?td@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_td: *mut nsAtom; + #[link_name = "\x01?_template@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__template: *mut nsAtom; + #[link_name = "\x01?text_decoration@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_text_decoration: *mut nsAtom; + #[link_name = "\x01?terminate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_terminate: *mut nsAtom; + #[link_name = "\x01?term@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_term: *mut nsAtom; + #[link_name = "\x01?test@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_test: *mut nsAtom; + #[link_name = "\x01?text@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_text: *mut nsAtom; + #[link_name = "\x01?textAlign@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_textAlign: *mut nsAtom; + #[link_name = "\x01?textarea@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_textarea: *mut nsAtom; + #[link_name = "\x01?textbox@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_textbox: *mut nsAtom; + #[link_name = "\x01?textnode@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_textnode: *mut nsAtom; + #[link_name = "\x01?textNodeDirectionalityMap@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_textNodeDirectionalityMap: *mut nsAtom; + #[link_name = "\x01?tfoot@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tfoot: *mut nsAtom; + #[link_name = "\x01?th@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_th: *mut nsAtom; + #[link_name = "\x01?thead@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_thead: *mut nsAtom; + #[link_name = "\x01?thumb@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_thumb: *mut nsAtom; + #[link_name = "\x01?time@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_time: *mut nsAtom; + #[link_name = "\x01?title@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_title: *mut nsAtom; + #[link_name = "\x01?titlebar@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_titlebar: *mut nsAtom; + #[link_name = "\x01?titletip@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_titletip: *mut nsAtom; + #[link_name = "\x01?toggled@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_toggled: *mut nsAtom; + #[link_name = "\x01?token@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_token: *mut nsAtom; + #[link_name = "\x01?tokenize@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tokenize: *mut nsAtom; + #[link_name = "\x01?toolbar@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_toolbar: *mut nsAtom; + #[link_name = "\x01?toolbarbutton@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_toolbarbutton: *mut nsAtom; + #[link_name = "\x01?toolbaritem@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_toolbaritem: *mut nsAtom; + #[link_name = "\x01?toolbox@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_toolbox: *mut nsAtom; + #[link_name = "\x01?tooltip@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tooltip: *mut nsAtom; + #[link_name = "\x01?tooltiptext@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tooltiptext: *mut nsAtom; + #[link_name = "\x01?top@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_top: *mut nsAtom; + #[link_name = "\x01?topleft@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_topleft: *mut nsAtom; + #[link_name = "\x01?topmargin@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_topmargin: *mut nsAtom; + #[link_name = "\x01?toppadding@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_toppadding: *mut nsAtom; + #[link_name = "\x01?topright@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_topright: *mut nsAtom; + #[link_name = "\x01?tr@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tr: *mut nsAtom; + #[link_name = "\x01?track@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_track: *mut nsAtom; + #[link_name = "\x01?trad_chinese_formal@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_trad_chinese_formal: *mut nsAtom; + #[link_name = "\x01?trad_chinese_informal@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_trad_chinese_informal: *mut nsAtom; + #[link_name = "\x01?trailing@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_trailing: *mut nsAtom; + #[link_name = "\x01?transform@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_transform: *mut nsAtom; + #[link_name = "\x01?transform_3d@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_transform_3d: *mut nsAtom; + #[link_name = "\x01?transformiix@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_transformiix: *mut nsAtom; + #[link_name = "\x01?translate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_translate: *mut nsAtom; + #[link_name = "\x01?transparent@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_transparent: *mut nsAtom; + #[link_name = "\x01?tree@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tree: *mut nsAtom; + #[link_name = "\x01?treecell@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_treecell: *mut nsAtom; + #[link_name = "\x01?treechildren@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_treechildren: *mut nsAtom; + #[link_name = "\x01?treecol@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_treecol: *mut nsAtom; + #[link_name = "\x01?treecolpicker@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_treecolpicker: *mut nsAtom; + #[link_name = "\x01?treecols@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_treecols: *mut nsAtom; + #[link_name = "\x01?treeitem@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_treeitem: *mut nsAtom; + #[link_name = "\x01?treerow@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_treerow: *mut nsAtom; + #[link_name = "\x01?treeseparator@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_treeseparator: *mut nsAtom; + #[link_name = "\x01?triple@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_triple: *mut nsAtom; + #[link_name = "\x01?_true@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__true: *mut nsAtom; + #[link_name = "\x01?tt@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tt: *mut nsAtom; + #[link_name = "\x01?tty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tty: *mut nsAtom; + #[link_name = "\x01?tv@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tv: *mut nsAtom; + #[link_name = "\x01?type@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_type: *mut nsAtom; + #[link_name = "\x01?typemustmatch@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_typemustmatch: *mut nsAtom; + #[link_name = "\x01?u@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_u: *mut nsAtom; + #[link_name = "\x01?ul@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ul: *mut nsAtom; + #[link_name = "\x01?underflow@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_underflow: *mut nsAtom; + #[link_name = "\x01?undetermined@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_undetermined: *mut nsAtom; + #[link_name = "\x01?unload@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_unload: *mut nsAtom; + #[link_name = "\x01?unparsedEntityUri@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_unparsedEntityUri: *mut nsAtom; + #[link_name = "\x01?upperAlpha@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_upperAlpha: *mut nsAtom; + #[link_name = "\x01?upperFirst@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_upperFirst: *mut nsAtom; + #[link_name = "\x01?upperRoman@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_upperRoman: *mut nsAtom; + #[link_name = "\x01?uri@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_uri: *mut nsAtom; + #[link_name = "\x01?use@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_use: *mut nsAtom; + #[link_name = "\x01?useAttributeSets@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_useAttributeSets: *mut nsAtom; + #[link_name = "\x01?usemap@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_usemap: *mut nsAtom; + #[link_name = "\x01?user_scalable@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_user_scalable: *mut nsAtom; + #[link_name = "\x01?userInput@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_userInput: *mut nsAtom; + #[link_name = "\x01?validate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_validate: *mut nsAtom; + #[link_name = "\x01?valign@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_valign: *mut nsAtom; + #[link_name = "\x01?value@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_value: *mut nsAtom; + #[link_name = "\x01?values@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_values: *mut nsAtom; + #[link_name = "\x01?valueOf@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_valueOf: *mut nsAtom; + #[link_name = "\x01?valuetype@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_valuetype: *mut nsAtom; + #[link_name = "\x01?var@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_var: *mut nsAtom; + #[link_name = "\x01?variable@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_variable: *mut nsAtom; + #[link_name = "\x01?vbox@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_vbox: *mut nsAtom; + #[link_name = "\x01?vcard_name@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_vcard_name: *mut nsAtom; + #[link_name = "\x01?vendor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_vendor: *mut nsAtom; + #[link_name = "\x01?vendorUrl@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_vendorUrl: *mut nsAtom; + #[link_name = "\x01?version@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_version: *mut nsAtom; + #[link_name = "\x01?vert@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_vert: *mut nsAtom; + #[link_name = "\x01?vertical@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_vertical: *mut nsAtom; + #[link_name = "\x01?audio@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_audio: *mut nsAtom; + #[link_name = "\x01?video@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_video: *mut nsAtom; + #[link_name = "\x01?videocontrols@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_videocontrols: *mut nsAtom; + #[link_name = "\x01?viewport@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_viewport: *mut nsAtom; + #[link_name = "\x01?viewport_height@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_viewport_height: *mut nsAtom; + #[link_name = "\x01?viewport_initial_scale@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_viewport_initial_scale: *mut nsAtom; + #[link_name = "\x01?viewport_maximum_scale@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_viewport_maximum_scale: *mut nsAtom; + #[link_name = "\x01?viewport_minimum_scale@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_viewport_minimum_scale: *mut nsAtom; + #[link_name = "\x01?viewport_user_scalable@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_viewport_user_scalable: *mut nsAtom; + #[link_name = "\x01?viewport_width@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_viewport_width: *mut nsAtom; + #[link_name = "\x01?visibility@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_visibility: *mut nsAtom; + #[link_name = "\x01?visuallyselected@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_visuallyselected: *mut nsAtom; + #[link_name = "\x01?vlink@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_vlink: *mut nsAtom; + #[link_name = "\x01?vspace@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_vspace: *mut nsAtom; + #[link_name = "\x01?wbr@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_wbr: *mut nsAtom; + #[link_name = "\x01?webkitdirectory@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_webkitdirectory: *mut nsAtom; + #[link_name = "\x01?when@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_when: *mut nsAtom; + #[link_name = "\x01?where@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_where: *mut nsAtom; + #[link_name = "\x01?widget@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_widget: *mut nsAtom; + #[link_name = "\x01?width@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_width: *mut nsAtom; + #[link_name = "\x01?willChange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_willChange: *mut nsAtom; + #[link_name = "\x01?window@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_window: *mut nsAtom; + #[link_name = "\x01?headerWindowTarget@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_headerWindowTarget: *mut nsAtom; + #[link_name = "\x01?windowtype@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_windowtype: *mut nsAtom; + #[link_name = "\x01?withParam@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_withParam: *mut nsAtom; + #[link_name = "\x01?wizard@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_wizard: *mut nsAtom; + #[link_name = "\x01?wrap@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_wrap: *mut nsAtom; + #[link_name = "\x01?headerDNSPrefetchControl@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_headerDNSPrefetchControl: *mut nsAtom; + #[link_name = "\x01?headerCSP@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_headerCSP: *mut nsAtom; + #[link_name = "\x01?headerCSPReportOnly@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_headerCSPReportOnly: *mut nsAtom; + #[link_name = "\x01?headerXFO@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_headerXFO: *mut nsAtom; + #[link_name = "\x01?x_western@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x_western: *mut nsAtom; + #[link_name = "\x01?xml@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xml: *mut nsAtom; + #[link_name = "\x01?xml_stylesheet@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xml_stylesheet: *mut nsAtom; + #[link_name = "\x01?xmlns@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xmlns: *mut nsAtom; + #[link_name = "\x01?xmp@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xmp: *mut nsAtom; + #[link_name = "\x01?xulcontentsgenerated@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xulcontentsgenerated: *mut nsAtom; + #[link_name = "\x01?yes@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_yes: *mut nsAtom; + #[link_name = "\x01?z_index@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_z_index: *mut nsAtom; + #[link_name = "\x01?zeroDigit@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_zeroDigit: *mut nsAtom; + #[link_name = "\x01?percentage@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_percentage: *mut nsAtom; + #[link_name = "\x01?A@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_A: *mut nsAtom; + #[link_name = "\x01?alignment_baseline@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_alignment_baseline: *mut nsAtom; + #[link_name = "\x01?amplitude@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_amplitude: *mut nsAtom; + #[link_name = "\x01?animate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_animate: *mut nsAtom; + #[link_name = "\x01?animateColor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_animateColor: *mut nsAtom; + #[link_name = "\x01?animateMotion@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_animateMotion: *mut nsAtom; + #[link_name = "\x01?animateTransform@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_animateTransform: *mut nsAtom; + #[link_name = "\x01?arithmetic@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_arithmetic: *mut nsAtom; + #[link_name = "\x01?atop@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_atop: *mut nsAtom; + #[link_name = "\x01?azimuth@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_azimuth: *mut nsAtom; + #[link_name = "\x01?B@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_B: *mut nsAtom; + #[link_name = "\x01?backgroundColor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_backgroundColor: *mut nsAtom; + #[link_name = "\x01?background_image@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_background_image: *mut nsAtom; + #[link_name = "\x01?baseFrequency@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_baseFrequency: *mut nsAtom; + #[link_name = "\x01?baseline_shift@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_baseline_shift: *mut nsAtom; + #[link_name = "\x01?bias@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_bias: *mut nsAtom; + #[link_name = "\x01?caption_side@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_caption_side: *mut nsAtom; + #[link_name = "\x01?clip_path@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_clip_path: *mut nsAtom; + #[link_name = "\x01?clip_rule@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_clip_rule: *mut nsAtom; + #[link_name = "\x01?clipPath@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_clipPath: *mut nsAtom; + #[link_name = "\x01?clipPathUnits@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_clipPathUnits: *mut nsAtom; + #[link_name = "\x01?cm@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cm: *mut nsAtom; + #[link_name = "\x01?colorBurn@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_colorBurn: *mut nsAtom; + #[link_name = "\x01?colorDodge@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_colorDodge: *mut nsAtom; + #[link_name = "\x01?colorInterpolation@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_colorInterpolation: *mut nsAtom; + #[link_name = "\x01?colorInterpolationFilters@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_colorInterpolationFilters: *mut nsAtom; + #[link_name = "\x01?colorProfile@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_colorProfile: *mut nsAtom; + #[link_name = "\x01?cursor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cursor: *mut nsAtom; + #[link_name = "\x01?cx@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cx: *mut nsAtom; + #[link_name = "\x01?cy@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cy: *mut nsAtom; + #[link_name = "\x01?d@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_d: *mut nsAtom; + #[link_name = "\x01?darken@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_darken: *mut nsAtom; + #[link_name = "\x01?defs@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_defs: *mut nsAtom; + #[link_name = "\x01?deg@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_deg: *mut nsAtom; + #[link_name = "\x01?desc@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_desc: *mut nsAtom; + #[link_name = "\x01?diffuseConstant@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_diffuseConstant: *mut nsAtom; + #[link_name = "\x01?dilate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dilate: *mut nsAtom; + #[link_name = "\x01?direction@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_direction: *mut nsAtom; + #[link_name = "\x01?disable@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_disable: *mut nsAtom; + #[link_name = "\x01?disc@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_disc: *mut nsAtom; + #[link_name = "\x01?discrete@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_discrete: *mut nsAtom; + #[link_name = "\x01?divisor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_divisor: *mut nsAtom; + #[link_name = "\x01?dominant_baseline@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dominant_baseline: *mut nsAtom; + #[link_name = "\x01?duplicate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_duplicate: *mut nsAtom; + #[link_name = "\x01?dx@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dx: *mut nsAtom; + #[link_name = "\x01?dy@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dy: *mut nsAtom; + #[link_name = "\x01?edgeMode@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_edgeMode: *mut nsAtom; + #[link_name = "\x01?ellipse@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ellipse: *mut nsAtom; + #[link_name = "\x01?elevation@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_elevation: *mut nsAtom; + #[link_name = "\x01?erode@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_erode: *mut nsAtom; + #[link_name = "\x01?ex@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ex: *mut nsAtom; + #[link_name = "\x01?exact@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_exact: *mut nsAtom; + #[link_name = "\x01?exclusion@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_exclusion: *mut nsAtom; + #[link_name = "\x01?exponent@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_exponent: *mut nsAtom; + #[link_name = "\x01?feBlend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feBlend: *mut nsAtom; + #[link_name = "\x01?feColorMatrix@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feColorMatrix: *mut nsAtom; + #[link_name = "\x01?feComponentTransfer@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feComponentTransfer: *mut nsAtom; + #[link_name = "\x01?feComposite@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feComposite: *mut nsAtom; + #[link_name = "\x01?feConvolveMatrix@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feConvolveMatrix: *mut nsAtom; + #[link_name = "\x01?feDiffuseLighting@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feDiffuseLighting: *mut nsAtom; + #[link_name = "\x01?feDisplacementMap@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feDisplacementMap: *mut nsAtom; + #[link_name = "\x01?feDistantLight@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feDistantLight: *mut nsAtom; + #[link_name = "\x01?feDropShadow@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feDropShadow: *mut nsAtom; + #[link_name = "\x01?feFlood@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feFlood: *mut nsAtom; + #[link_name = "\x01?feFuncA@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feFuncA: *mut nsAtom; + #[link_name = "\x01?feFuncB@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feFuncB: *mut nsAtom; + #[link_name = "\x01?feFuncG@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feFuncG: *mut nsAtom; + #[link_name = "\x01?feFuncR@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feFuncR: *mut nsAtom; + #[link_name = "\x01?feGaussianBlur@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feGaussianBlur: *mut nsAtom; + #[link_name = "\x01?feImage@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feImage: *mut nsAtom; + #[link_name = "\x01?feMerge@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feMerge: *mut nsAtom; + #[link_name = "\x01?feMergeNode@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feMergeNode: *mut nsAtom; + #[link_name = "\x01?feMorphology@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feMorphology: *mut nsAtom; + #[link_name = "\x01?feOffset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feOffset: *mut nsAtom; + #[link_name = "\x01?fePointLight@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fePointLight: *mut nsAtom; + #[link_name = "\x01?feSpecularLighting@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feSpecularLighting: *mut nsAtom; + #[link_name = "\x01?feSpotLight@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feSpotLight: *mut nsAtom; + #[link_name = "\x01?feTile@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feTile: *mut nsAtom; + #[link_name = "\x01?feTurbulence@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feTurbulence: *mut nsAtom; + #[link_name = "\x01?fill@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fill: *mut nsAtom; + #[link_name = "\x01?fill_opacity@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fill_opacity: *mut nsAtom; + #[link_name = "\x01?fill_rule@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fill_rule: *mut nsAtom; + #[link_name = "\x01?filter@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_filter: *mut nsAtom; + #[link_name = "\x01?filterUnits@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_filterUnits: *mut nsAtom; + #[link_name = "\x01?_float@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__float: *mut nsAtom; + #[link_name = "\x01?flood_color@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_flood_color: *mut nsAtom; + #[link_name = "\x01?flood_opacity@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_flood_opacity: *mut nsAtom; + #[link_name = "\x01?font_face@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_font_face: *mut nsAtom; + #[link_name = "\x01?font_face_format@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_font_face_format: *mut nsAtom; + #[link_name = "\x01?font_face_name@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_font_face_name: *mut nsAtom; + #[link_name = "\x01?font_face_src@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_font_face_src: *mut nsAtom; + #[link_name = "\x01?font_face_uri@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_font_face_uri: *mut nsAtom; + #[link_name = "\x01?font_family@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_font_family: *mut nsAtom; + #[link_name = "\x01?font_size@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_font_size: *mut nsAtom; + #[link_name = "\x01?font_size_adjust@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_font_size_adjust: *mut nsAtom; + #[link_name = "\x01?font_stretch@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_font_stretch: *mut nsAtom; + #[link_name = "\x01?font_style@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_font_style: *mut nsAtom; + #[link_name = "\x01?font_variant@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_font_variant: *mut nsAtom; + #[link_name = "\x01?foreignObject@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_foreignObject: *mut nsAtom; + #[link_name = "\x01?fractalNoise@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fractalNoise: *mut nsAtom; + #[link_name = "\x01?fr@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fr: *mut nsAtom; + #[link_name = "\x01?fx@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fx: *mut nsAtom; + #[link_name = "\x01?fy@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fy: *mut nsAtom; + #[link_name = "\x01?G@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_G: *mut nsAtom; + #[link_name = "\x01?g@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_g: *mut nsAtom; + #[link_name = "\x01?gamma@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_gamma: *mut nsAtom; + #[link_name = "\x01?generic_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_generic_: *mut nsAtom; + #[link_name = "\x01?glyphRef@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_glyphRef: *mut nsAtom; + #[link_name = "\x01?grad@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_grad: *mut nsAtom; + #[link_name = "\x01?gradientTransform@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_gradientTransform: *mut nsAtom; + #[link_name = "\x01?gradientUnits@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_gradientUnits: *mut nsAtom; + #[link_name = "\x01?hardLight@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_hardLight: *mut nsAtom; + #[link_name = "\x01?hue@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_hue: *mut nsAtom; + #[link_name = "\x01?hueRotate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_hueRotate: *mut nsAtom; + #[link_name = "\x01?identity@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_identity: *mut nsAtom; + #[link_name = "\x01?image_rendering@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_image_rendering: *mut nsAtom; + #[link_name = "\x01?in@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_in: *mut nsAtom; + #[link_name = "\x01?in2@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_in2: *mut nsAtom; + #[link_name = "\x01?intercept@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_intercept: *mut nsAtom; + #[link_name = "\x01?k1@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_k1: *mut nsAtom; + #[link_name = "\x01?k2@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_k2: *mut nsAtom; + #[link_name = "\x01?k3@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_k3: *mut nsAtom; + #[link_name = "\x01?k4@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_k4: *mut nsAtom; + #[link_name = "\x01?kernelMatrix@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_kernelMatrix: *mut nsAtom; + #[link_name = "\x01?kernelUnitLength@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_kernelUnitLength: *mut nsAtom; + #[link_name = "\x01?lengthAdjust@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lengthAdjust: *mut nsAtom; + #[link_name = "\x01?letter_spacing@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_letter_spacing: *mut nsAtom; + #[link_name = "\x01?lighten@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lighten: *mut nsAtom; + #[link_name = "\x01?lighting_color@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lighting_color: *mut nsAtom; + #[link_name = "\x01?limitingConeAngle@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_limitingConeAngle: *mut nsAtom; + #[link_name = "\x01?linear@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_linear: *mut nsAtom; + #[link_name = "\x01?linearGradient@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_linearGradient: *mut nsAtom; + #[link_name = "\x01?linearRGB@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_linearRGB: *mut nsAtom; + #[link_name = "\x01?list_style_type@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_list_style_type: *mut nsAtom; + #[link_name = "\x01?luminanceToAlpha@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_luminanceToAlpha: *mut nsAtom; + #[link_name = "\x01?luminosity@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_luminosity: *mut nsAtom; + #[link_name = "\x01?magnify@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_magnify: *mut nsAtom; + #[link_name = "\x01?marker@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_marker: *mut nsAtom; + #[link_name = "\x01?marker_end@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_marker_end: *mut nsAtom; + #[link_name = "\x01?marker_mid@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_marker_mid: *mut nsAtom; + #[link_name = "\x01?marker_start@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_marker_start: *mut nsAtom; + #[link_name = "\x01?markerHeight@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_markerHeight: *mut nsAtom; + #[link_name = "\x01?markerUnits@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_markerUnits: *mut nsAtom; + #[link_name = "\x01?markerWidth@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_markerWidth: *mut nsAtom; + #[link_name = "\x01?mask@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mask: *mut nsAtom; + #[link_name = "\x01?maskContentUnits@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_maskContentUnits: *mut nsAtom; + #[link_name = "\x01?mask_type@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mask_type: *mut nsAtom; + #[link_name = "\x01?maskUnits@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_maskUnits: *mut nsAtom; + #[link_name = "\x01?matrix@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_matrix: *mut nsAtom; + #[link_name = "\x01?metadata@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_metadata: *mut nsAtom; + #[link_name = "\x01?missingGlyph@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_missingGlyph: *mut nsAtom; + #[link_name = "\x01?mm@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mm: *mut nsAtom; + #[link_name = "\x01?mpath@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mpath: *mut nsAtom; + #[link_name = "\x01?noStitch@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_noStitch: *mut nsAtom; + #[link_name = "\x01?numOctaves@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_numOctaves: *mut nsAtom; + #[link_name = "\x01?multiply@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_multiply: *mut nsAtom; + #[link_name = "\x01?objectBoundingBox@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_objectBoundingBox: *mut nsAtom; + #[link_name = "\x01?offset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_offset: *mut nsAtom; + #[link_name = "\x01?onSVGLoad@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onSVGLoad: *mut nsAtom; + #[link_name = "\x01?onSVGResize@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onSVGResize: *mut nsAtom; + #[link_name = "\x01?onSVGScroll@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onSVGScroll: *mut nsAtom; + #[link_name = "\x01?onSVGUnload@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onSVGUnload: *mut nsAtom; + #[link_name = "\x01?onSVGZoom@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onSVGZoom: *mut nsAtom; + #[link_name = "\x01?onzoom@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onzoom: *mut nsAtom; + #[link_name = "\x01?opacity@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_opacity: *mut nsAtom; + #[link_name = "\x01?_operator@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__operator: *mut nsAtom; + #[link_name = "\x01?out@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_out: *mut nsAtom; + #[link_name = "\x01?over@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_over: *mut nsAtom; + #[link_name = "\x01?overridePreserveAspectRatio@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_overridePreserveAspectRatio: *mut nsAtom; + #[link_name = "\x01?pad@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pad: *mut nsAtom; + #[link_name = "\x01?path@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_path: *mut nsAtom; + #[link_name = "\x01?pathLength@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pathLength: *mut nsAtom; + #[link_name = "\x01?patternContentUnits@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_patternContentUnits: *mut nsAtom; + #[link_name = "\x01?patternTransform@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_patternTransform: *mut nsAtom; + #[link_name = "\x01?patternUnits@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_patternUnits: *mut nsAtom; + #[link_name = "\x01?pc@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pc: *mut nsAtom; + #[link_name = "\x01?pointer_events@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pointer_events: *mut nsAtom; + #[link_name = "\x01?points@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_points: *mut nsAtom; + #[link_name = "\x01?pointsAtX@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pointsAtX: *mut nsAtom; + #[link_name = "\x01?pointsAtY@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pointsAtY: *mut nsAtom; + #[link_name = "\x01?pointsAtZ@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pointsAtZ: *mut nsAtom; + #[link_name = "\x01?polyline@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_polyline: *mut nsAtom; + #[link_name = "\x01?preserveAlpha@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_preserveAlpha: *mut nsAtom; + #[link_name = "\x01?preserveAspectRatio@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_preserveAspectRatio: *mut nsAtom; + #[link_name = "\x01?primitiveUnits@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_primitiveUnits: *mut nsAtom; + #[link_name = "\x01?pt@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pt: *mut nsAtom; + #[link_name = "\x01?px@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_px: *mut nsAtom; + #[link_name = "\x01?R@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_R: *mut nsAtom; + #[link_name = "\x01?r@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_r: *mut nsAtom; + #[link_name = "\x01?rad@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rad: *mut nsAtom; + #[link_name = "\x01?radialGradient@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_radialGradient: *mut nsAtom; + #[link_name = "\x01?radius@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_radius: *mut nsAtom; + #[link_name = "\x01?reflect@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_reflect: *mut nsAtom; + #[link_name = "\x01?refX@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_refX: *mut nsAtom; + #[link_name = "\x01?refY@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_refY: *mut nsAtom; + #[link_name = "\x01?requiredExtensions@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_requiredExtensions: *mut nsAtom; + #[link_name = "\x01?requiredFeatures@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_requiredFeatures: *mut nsAtom; + #[link_name = "\x01?rotate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rotate: *mut nsAtom; + #[link_name = "\x01?rx@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rx: *mut nsAtom; + #[link_name = "\x01?ry@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ry: *mut nsAtom; + #[link_name = "\x01?saturate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_saturate: *mut nsAtom; + #[link_name = "\x01?saturation@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_saturation: *mut nsAtom; + #[link_name = "\x01?set@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_set: *mut nsAtom; + #[link_name = "\x01?seed@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_seed: *mut nsAtom; + #[link_name = "\x01?shape_rendering@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_shape_rendering: *mut nsAtom; + #[link_name = "\x01?skewX@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_skewX: *mut nsAtom; + #[link_name = "\x01?skewY@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_skewY: *mut nsAtom; + #[link_name = "\x01?slope@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_slope: *mut nsAtom; + #[link_name = "\x01?slot@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_slot: *mut nsAtom; + #[link_name = "\x01?softLight@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_softLight: *mut nsAtom; + #[link_name = "\x01?spacing@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_spacing: *mut nsAtom; + #[link_name = "\x01?spacingAndGlyphs@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_spacingAndGlyphs: *mut nsAtom; + #[link_name = "\x01?specularConstant@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_specularConstant: *mut nsAtom; + #[link_name = "\x01?specularExponent@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_specularExponent: *mut nsAtom; + #[link_name = "\x01?spreadMethod@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_spreadMethod: *mut nsAtom; + #[link_name = "\x01?sRGB@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sRGB: *mut nsAtom; + #[link_name = "\x01?startOffset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_startOffset: *mut nsAtom; + #[link_name = "\x01?stdDeviation@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stdDeviation: *mut nsAtom; + #[link_name = "\x01?stitch@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stitch: *mut nsAtom; + #[link_name = "\x01?stitchTiles@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stitchTiles: *mut nsAtom; + #[link_name = "\x01?stop_color@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stop_color: *mut nsAtom; + #[link_name = "\x01?stop_opacity@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stop_opacity: *mut nsAtom; + #[link_name = "\x01?stroke@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stroke: *mut nsAtom; + #[link_name = "\x01?stroke_dasharray@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stroke_dasharray: *mut nsAtom; + #[link_name = "\x01?stroke_dashoffset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stroke_dashoffset: *mut nsAtom; + #[link_name = "\x01?stroke_linecap@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stroke_linecap: *mut nsAtom; + #[link_name = "\x01?stroke_linejoin@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stroke_linejoin: *mut nsAtom; + #[link_name = "\x01?stroke_miterlimit@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stroke_miterlimit: *mut nsAtom; + #[link_name = "\x01?stroke_opacity@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stroke_opacity: *mut nsAtom; + #[link_name = "\x01?stroke_width@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stroke_width: *mut nsAtom; + #[link_name = "\x01?strokeWidth@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_strokeWidth: *mut nsAtom; + #[link_name = "\x01?surfaceScale@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_surfaceScale: *mut nsAtom; + #[link_name = "\x01?svg@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_svg: *mut nsAtom; + #[link_name = "\x01?svgContextPaint@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_svgContextPaint: *mut nsAtom; + #[link_name = "\x01?svgSwitch@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_svgSwitch: *mut nsAtom; + #[link_name = "\x01?symbol@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_symbol: *mut nsAtom; + #[link_name = "\x01?systemLanguage@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_systemLanguage: *mut nsAtom; + #[link_name = "\x01?tableValues@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tableValues: *mut nsAtom; + #[link_name = "\x01?targetX@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_targetX: *mut nsAtom; + #[link_name = "\x01?targetY@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_targetY: *mut nsAtom; + #[link_name = "\x01?text_anchor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_text_anchor: *mut nsAtom; + #[link_name = "\x01?text_rendering@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_text_rendering: *mut nsAtom; + #[link_name = "\x01?textLength@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_textLength: *mut nsAtom; + #[link_name = "\x01?textPath@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_textPath: *mut nsAtom; + #[link_name = "\x01?tref@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tref: *mut nsAtom; + #[link_name = "\x01?tspan@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tspan: *mut nsAtom; + #[link_name = "\x01?turbulence@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_turbulence: *mut nsAtom; + #[link_name = "\x01?unicode_bidi@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_unicode_bidi: *mut nsAtom; + #[link_name = "\x01?userSpaceOnUse@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_userSpaceOnUse: *mut nsAtom; + #[link_name = "\x01?view@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_view: *mut nsAtom; + #[link_name = "\x01?viewBox@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_viewBox: *mut nsAtom; + #[link_name = "\x01?viewTarget@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_viewTarget: *mut nsAtom; + #[link_name = "\x01?white_space@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_white_space: *mut nsAtom; + #[link_name = "\x01?word_spacing@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_word_spacing: *mut nsAtom; + #[link_name = "\x01?writing_mode@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_writing_mode: *mut nsAtom; + #[link_name = "\x01?x@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x: *mut nsAtom; + #[link_name = "\x01?x1@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x1: *mut nsAtom; + #[link_name = "\x01?x2@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x2: *mut nsAtom; + #[link_name = "\x01?xChannelSelector@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xChannelSelector: *mut nsAtom; + #[link_name = "\x01?xor_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xor_: *mut nsAtom; + #[link_name = "\x01?y@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_y: *mut nsAtom; + #[link_name = "\x01?y1@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_y1: *mut nsAtom; + #[link_name = "\x01?y2@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_y2: *mut nsAtom; + #[link_name = "\x01?yChannelSelector@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_yChannelSelector: *mut nsAtom; + #[link_name = "\x01?z@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_z: *mut nsAtom; + #[link_name = "\x01?zoomAndPan@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_zoomAndPan: *mut nsAtom; + #[link_name = "\x01?vector_effect@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_vector_effect: *mut nsAtom; + #[link_name = "\x01?vertical_align@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_vertical_align: *mut nsAtom; + #[link_name = "\x01?accumulate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_accumulate: *mut nsAtom; + #[link_name = "\x01?additive@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_additive: *mut nsAtom; + #[link_name = "\x01?attributeName@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_attributeName: *mut nsAtom; + #[link_name = "\x01?attributeType@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_attributeType: *mut nsAtom; + #[link_name = "\x01?auto_reverse@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_auto_reverse: *mut nsAtom; + #[link_name = "\x01?begin@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_begin: *mut nsAtom; + #[link_name = "\x01?beginEvent@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_beginEvent: *mut nsAtom; + #[link_name = "\x01?by@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_by: *mut nsAtom; + #[link_name = "\x01?calcMode@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_calcMode: *mut nsAtom; + #[link_name = "\x01?css@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_css: *mut nsAtom; + #[link_name = "\x01?dur@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_dur: *mut nsAtom; + #[link_name = "\x01?keyPoints@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_keyPoints: *mut nsAtom; + #[link_name = "\x01?keySplines@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_keySplines: *mut nsAtom; + #[link_name = "\x01?keyTimes@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_keyTimes: *mut nsAtom; + #[link_name = "\x01?mozAnimateMotionDummyAttr@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozAnimateMotionDummyAttr: *mut nsAtom; + #[link_name = "\x01?onbegin@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onbegin: *mut nsAtom; + #[link_name = "\x01?onbeginEvent@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onbeginEvent: *mut nsAtom; + #[link_name = "\x01?onend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onend: *mut nsAtom; + #[link_name = "\x01?onendEvent@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onendEvent: *mut nsAtom; + #[link_name = "\x01?onrepeat@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onrepeat: *mut nsAtom; + #[link_name = "\x01?onrepeatEvent@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onrepeatEvent: *mut nsAtom; + #[link_name = "\x01?repeatCount@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_repeatCount: *mut nsAtom; + #[link_name = "\x01?repeatDur@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_repeatDur: *mut nsAtom; + #[link_name = "\x01?repeatEvent@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_repeatEvent: *mut nsAtom; + #[link_name = "\x01?restart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_restart: *mut nsAtom; + #[link_name = "\x01?to@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_to: *mut nsAtom; + #[link_name = "\x01?XML@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_XML: *mut nsAtom; + #[link_name = "\x01?abs_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_abs_: *mut nsAtom; + #[link_name = "\x01?accent_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_accent_: *mut nsAtom; + #[link_name = "\x01?accentunder_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_accentunder_: *mut nsAtom; + #[link_name = "\x01?actiontype_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_actiontype_: *mut nsAtom; + #[link_name = "\x01?alignmentscope_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_alignmentscope_: *mut nsAtom; + #[link_name = "\x01?altimg_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_altimg_: *mut nsAtom; + #[link_name = "\x01?altimg_height_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_altimg_height_: *mut nsAtom; + #[link_name = "\x01?altimg_valign_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_altimg_valign_: *mut nsAtom; + #[link_name = "\x01?altimg_width_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_altimg_width_: *mut nsAtom; + #[link_name = "\x01?annotation_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_annotation_: *mut nsAtom; + #[link_name = "\x01?annotation_xml_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_annotation_xml_: *mut nsAtom; + #[link_name = "\x01?apply_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_apply_: *mut nsAtom; + #[link_name = "\x01?approx_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_approx_: *mut nsAtom; + #[link_name = "\x01?arccos_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_arccos_: *mut nsAtom; + #[link_name = "\x01?arccosh_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_arccosh_: *mut nsAtom; + #[link_name = "\x01?arccot_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_arccot_: *mut nsAtom; + #[link_name = "\x01?arccoth_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_arccoth_: *mut nsAtom; + #[link_name = "\x01?arccsc_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_arccsc_: *mut nsAtom; + #[link_name = "\x01?arccsch_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_arccsch_: *mut nsAtom; + #[link_name = "\x01?arcsec_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_arcsec_: *mut nsAtom; + #[link_name = "\x01?arcsech_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_arcsech_: *mut nsAtom; + #[link_name = "\x01?arcsin_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_arcsin_: *mut nsAtom; + #[link_name = "\x01?arcsinh_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_arcsinh_: *mut nsAtom; + #[link_name = "\x01?arctan_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_arctan_: *mut nsAtom; + #[link_name = "\x01?arctanh_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_arctanh_: *mut nsAtom; + #[link_name = "\x01?arg_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_arg_: *mut nsAtom; + #[link_name = "\x01?bevelled_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_bevelled_: *mut nsAtom; + #[link_name = "\x01?bind_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_bind_: *mut nsAtom; + #[link_name = "\x01?bvar_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_bvar_: *mut nsAtom; + #[link_name = "\x01?card_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_card_: *mut nsAtom; + #[link_name = "\x01?cartesianproduct_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cartesianproduct_: *mut nsAtom; + #[link_name = "\x01?cbytes_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cbytes_: *mut nsAtom; + #[link_name = "\x01?cd_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cd_: *mut nsAtom; + #[link_name = "\x01?cdgroup_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cdgroup_: *mut nsAtom; + #[link_name = "\x01?cerror_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cerror_: *mut nsAtom; + #[link_name = "\x01?charalign_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_charalign_: *mut nsAtom; + #[link_name = "\x01?ci_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ci_: *mut nsAtom; + #[link_name = "\x01?closure_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_closure_: *mut nsAtom; + #[link_name = "\x01?cn_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cn_: *mut nsAtom; + #[link_name = "\x01?codomain_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_codomain_: *mut nsAtom; + #[link_name = "\x01?columnalign_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_columnalign_: *mut nsAtom; + #[link_name = "\x01?columnalignment_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_columnalignment_: *mut nsAtom; + #[link_name = "\x01?columnlines_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_columnlines_: *mut nsAtom; + #[link_name = "\x01?columnspacing_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_columnspacing_: *mut nsAtom; + #[link_name = "\x01?columnspan_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_columnspan_: *mut nsAtom; + #[link_name = "\x01?columnwidth_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_columnwidth_: *mut nsAtom; + #[link_name = "\x01?complexes_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_complexes_: *mut nsAtom; + #[link_name = "\x01?compose_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_compose_: *mut nsAtom; + #[link_name = "\x01?condition_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_condition_: *mut nsAtom; + #[link_name = "\x01?conjugate_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_conjugate_: *mut nsAtom; + #[link_name = "\x01?cos_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cos_: *mut nsAtom; + #[link_name = "\x01?cosh_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cosh_: *mut nsAtom; + #[link_name = "\x01?cot_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cot_: *mut nsAtom; + #[link_name = "\x01?coth_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_coth_: *mut nsAtom; + #[link_name = "\x01?crossout_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_crossout_: *mut nsAtom; + #[link_name = "\x01?csc_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_csc_: *mut nsAtom; + #[link_name = "\x01?csch_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_csch_: *mut nsAtom; + #[link_name = "\x01?cs_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cs_: *mut nsAtom; + #[link_name = "\x01?csymbol_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_csymbol_: *mut nsAtom; + #[link_name = "\x01?curl_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_curl_: *mut nsAtom; + #[link_name = "\x01?decimalpoint_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_decimalpoint_: *mut nsAtom; + #[link_name = "\x01?definitionURL_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_definitionURL_: *mut nsAtom; + #[link_name = "\x01?degree_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_degree_: *mut nsAtom; + #[link_name = "\x01?denomalign_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_denomalign_: *mut nsAtom; + #[link_name = "\x01?depth_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_depth_: *mut nsAtom; + #[link_name = "\x01?determinant_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_determinant_: *mut nsAtom; + #[link_name = "\x01?diff_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_diff_: *mut nsAtom; + #[link_name = "\x01?displaystyle_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_displaystyle_: *mut nsAtom; + #[link_name = "\x01?divergence_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_divergence_: *mut nsAtom; + #[link_name = "\x01?divide_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_divide_: *mut nsAtom; + #[link_name = "\x01?domain_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_domain_: *mut nsAtom; + #[link_name = "\x01?domainofapplication_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_domainofapplication_: *mut nsAtom; + #[link_name = "\x01?edge_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_edge_: *mut nsAtom; + #[link_name = "\x01?el_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_el_: *mut nsAtom; + #[link_name = "\x01?emptyset_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_emptyset_: *mut nsAtom; + #[link_name = "\x01?eq_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_eq_: *mut nsAtom; + #[link_name = "\x01?equalcolumns_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_equalcolumns_: *mut nsAtom; + #[link_name = "\x01?equalrows_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_equalrows_: *mut nsAtom; + #[link_name = "\x01?equivalent_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_equivalent_: *mut nsAtom; + #[link_name = "\x01?eulergamma_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_eulergamma_: *mut nsAtom; + #[link_name = "\x01?exists_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_exists_: *mut nsAtom; + #[link_name = "\x01?exp_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_exp_: *mut nsAtom; + #[link_name = "\x01?exponentiale_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_exponentiale_: *mut nsAtom; + #[link_name = "\x01?factorial_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_factorial_: *mut nsAtom; + #[link_name = "\x01?factorof_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_factorof_: *mut nsAtom; + #[link_name = "\x01?fence_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fence_: *mut nsAtom; + #[link_name = "\x01?fn_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fn_: *mut nsAtom; + #[link_name = "\x01?fontfamily_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fontfamily_: *mut nsAtom; + #[link_name = "\x01?fontsize_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fontsize_: *mut nsAtom; + #[link_name = "\x01?fontstyle_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fontstyle_: *mut nsAtom; + #[link_name = "\x01?fontweight_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fontweight_: *mut nsAtom; + #[link_name = "\x01?forall_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_forall_: *mut nsAtom; + #[link_name = "\x01?framespacing_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_framespacing_: *mut nsAtom; + #[link_name = "\x01?gcd_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_gcd_: *mut nsAtom; + #[link_name = "\x01?geq_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_geq_: *mut nsAtom; + #[link_name = "\x01?groupalign_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_groupalign_: *mut nsAtom; + #[link_name = "\x01?gt_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_gt_: *mut nsAtom; + #[link_name = "\x01?ident_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ident_: *mut nsAtom; + #[link_name = "\x01?imaginaryi_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_imaginaryi_: *mut nsAtom; + #[link_name = "\x01?imaginary_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_imaginary_: *mut nsAtom; + #[link_name = "\x01?implies_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_implies_: *mut nsAtom; + #[link_name = "\x01?indentalignfirst_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_indentalignfirst_: *mut nsAtom; + #[link_name = "\x01?indentalign_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_indentalign_: *mut nsAtom; + #[link_name = "\x01?indentalignlast_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_indentalignlast_: *mut nsAtom; + #[link_name = "\x01?indentshiftfirst_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_indentshiftfirst_: *mut nsAtom; + #[link_name = "\x01?indentshift_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_indentshift_: *mut nsAtom; + #[link_name = "\x01?indenttarget_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_indenttarget_: *mut nsAtom; + #[link_name = "\x01?integers_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_integers_: *mut nsAtom; + #[link_name = "\x01?intersect_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_intersect_: *mut nsAtom; + #[link_name = "\x01?interval_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_interval_: *mut nsAtom; + #[link_name = "\x01?int_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_int_: *mut nsAtom; + #[link_name = "\x01?inverse_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_inverse_: *mut nsAtom; + #[link_name = "\x01?lambda_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lambda_: *mut nsAtom; + #[link_name = "\x01?laplacian_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_laplacian_: *mut nsAtom; + #[link_name = "\x01?largeop_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_largeop_: *mut nsAtom; + #[link_name = "\x01?lcm_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lcm_: *mut nsAtom; + #[link_name = "\x01?leq_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_leq_: *mut nsAtom; + #[link_name = "\x01?limit_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_limit_: *mut nsAtom; + #[link_name = "\x01?linebreak_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_linebreak_: *mut nsAtom; + #[link_name = "\x01?linebreakmultchar_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_linebreakmultchar_: *mut nsAtom; + #[link_name = "\x01?linebreakstyle_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_linebreakstyle_: *mut nsAtom; + #[link_name = "\x01?linethickness_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_linethickness_: *mut nsAtom; + #[link_name = "\x01?list_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_list_: *mut nsAtom; + #[link_name = "\x01?ln_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ln_: *mut nsAtom; + #[link_name = "\x01?location_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_location_: *mut nsAtom; + #[link_name = "\x01?logbase_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_logbase_: *mut nsAtom; + #[link_name = "\x01?log_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_log_: *mut nsAtom; + #[link_name = "\x01?longdivstyle_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_longdivstyle_: *mut nsAtom; + #[link_name = "\x01?lowlimit_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lowlimit_: *mut nsAtom; + #[link_name = "\x01?lquote_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lquote_: *mut nsAtom; + #[link_name = "\x01?lspace_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lspace_: *mut nsAtom; + #[link_name = "\x01?lt_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lt_: *mut nsAtom; + #[link_name = "\x01?maction_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_maction_: *mut nsAtom; + #[link_name = "\x01?maligngroup_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_maligngroup_: *mut nsAtom; + #[link_name = "\x01?malignmark_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_malignmark_: *mut nsAtom; + #[link_name = "\x01?mathbackground_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mathbackground_: *mut nsAtom; + #[link_name = "\x01?mathcolor_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mathcolor_: *mut nsAtom; + #[link_name = "\x01?mathsize_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mathsize_: *mut nsAtom; + #[link_name = "\x01?mathvariant_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mathvariant_: *mut nsAtom; + #[link_name = "\x01?matrixrow_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_matrixrow_: *mut nsAtom; + #[link_name = "\x01?maxsize_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_maxsize_: *mut nsAtom; + #[link_name = "\x01?mean_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mean_: *mut nsAtom; + #[link_name = "\x01?median_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_median_: *mut nsAtom; + #[link_name = "\x01?menclose_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_menclose_: *mut nsAtom; + #[link_name = "\x01?merror_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_merror_: *mut nsAtom; + #[link_name = "\x01?mfenced_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mfenced_: *mut nsAtom; + #[link_name = "\x01?mfrac_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mfrac_: *mut nsAtom; + #[link_name = "\x01?mglyph_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mglyph_: *mut nsAtom; + #[link_name = "\x01?mi_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mi_: *mut nsAtom; + #[link_name = "\x01?minlabelspacing_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_minlabelspacing_: *mut nsAtom; + #[link_name = "\x01?minsize_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_minsize_: *mut nsAtom; + #[link_name = "\x01?minus_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_minus_: *mut nsAtom; + #[link_name = "\x01?mlabeledtr_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mlabeledtr_: *mut nsAtom; + #[link_name = "\x01?mlongdiv_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mlongdiv_: *mut nsAtom; + #[link_name = "\x01?mmultiscripts_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mmultiscripts_: *mut nsAtom; + #[link_name = "\x01?mn_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mn_: *mut nsAtom; + #[link_name = "\x01?momentabout_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_momentabout_: *mut nsAtom; + #[link_name = "\x01?moment_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_moment_: *mut nsAtom; + #[link_name = "\x01?mo_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mo_: *mut nsAtom; + #[link_name = "\x01?movablelimits_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_movablelimits_: *mut nsAtom; + #[link_name = "\x01?mover_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mover_: *mut nsAtom; + #[link_name = "\x01?mpadded_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mpadded_: *mut nsAtom; + #[link_name = "\x01?mphantom_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mphantom_: *mut nsAtom; + #[link_name = "\x01?mprescripts_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mprescripts_: *mut nsAtom; + #[link_name = "\x01?mroot_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mroot_: *mut nsAtom; + #[link_name = "\x01?mrow_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mrow_: *mut nsAtom; + #[link_name = "\x01?mscarries_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mscarries_: *mut nsAtom; + #[link_name = "\x01?mscarry_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mscarry_: *mut nsAtom; + #[link_name = "\x01?msgroup_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_msgroup_: *mut nsAtom; + #[link_name = "\x01?msline_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_msline_: *mut nsAtom; + #[link_name = "\x01?ms_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ms_: *mut nsAtom; + #[link_name = "\x01?mspace_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mspace_: *mut nsAtom; + #[link_name = "\x01?msqrt_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_msqrt_: *mut nsAtom; + #[link_name = "\x01?msrow_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_msrow_: *mut nsAtom; + #[link_name = "\x01?mstack_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mstack_: *mut nsAtom; + #[link_name = "\x01?mstyle_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mstyle_: *mut nsAtom; + #[link_name = "\x01?msub_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_msub_: *mut nsAtom; + #[link_name = "\x01?msubsup_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_msubsup_: *mut nsAtom; + #[link_name = "\x01?msup_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_msup_: *mut nsAtom; + #[link_name = "\x01?mtable_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mtable_: *mut nsAtom; + #[link_name = "\x01?mtd_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mtd_: *mut nsAtom; + #[link_name = "\x01?mtext_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mtext_: *mut nsAtom; + #[link_name = "\x01?mtr_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mtr_: *mut nsAtom; + #[link_name = "\x01?munder_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_munder_: *mut nsAtom; + #[link_name = "\x01?munderover_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_munderover_: *mut nsAtom; + #[link_name = "\x01?naturalnumbers_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_naturalnumbers_: *mut nsAtom; + #[link_name = "\x01?neq_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_neq_: *mut nsAtom; + #[link_name = "\x01?notanumber_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_notanumber_: *mut nsAtom; + #[link_name = "\x01?notation_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_notation_: *mut nsAtom; + #[link_name = "\x01?note_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_note_: *mut nsAtom; + #[link_name = "\x01?notin_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_notin_: *mut nsAtom; + #[link_name = "\x01?notprsubset_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_notprsubset_: *mut nsAtom; + #[link_name = "\x01?notsubset_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_notsubset_: *mut nsAtom; + #[link_name = "\x01?numalign_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_numalign_: *mut nsAtom; + #[link_name = "\x01?other_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_other_: *mut nsAtom; + #[link_name = "\x01?outerproduct_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_outerproduct_: *mut nsAtom; + #[link_name = "\x01?partialdiff_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_partialdiff_: *mut nsAtom; + #[link_name = "\x01?piece_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_piece_: *mut nsAtom; + #[link_name = "\x01?piecewise_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_piecewise_: *mut nsAtom; + #[link_name = "\x01?pi_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pi_: *mut nsAtom; + #[link_name = "\x01?plus_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_plus_: *mut nsAtom; + #[link_name = "\x01?power_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_power_: *mut nsAtom; + #[link_name = "\x01?primes_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_primes_: *mut nsAtom; + #[link_name = "\x01?product_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_product_: *mut nsAtom; + #[link_name = "\x01?prsubset_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_prsubset_: *mut nsAtom; + #[link_name = "\x01?quotient_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_quotient_: *mut nsAtom; + #[link_name = "\x01?rationals_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rationals_: *mut nsAtom; + #[link_name = "\x01?real_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_real_: *mut nsAtom; + #[link_name = "\x01?reals_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_reals_: *mut nsAtom; + #[link_name = "\x01?reln_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_reln_: *mut nsAtom; + #[link_name = "\x01?root_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_root_: *mut nsAtom; + #[link_name = "\x01?rowalign_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rowalign_: *mut nsAtom; + #[link_name = "\x01?rowlines_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rowlines_: *mut nsAtom; + #[link_name = "\x01?rowspacing_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rowspacing_: *mut nsAtom; + #[link_name = "\x01?rquote_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rquote_: *mut nsAtom; + #[link_name = "\x01?rspace_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rspace_: *mut nsAtom; + #[link_name = "\x01?scalarproduct_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scalarproduct_: *mut nsAtom; + #[link_name = "\x01?schemaLocation_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_schemaLocation_: *mut nsAtom; + #[link_name = "\x01?scriptlevel_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scriptlevel_: *mut nsAtom; + #[link_name = "\x01?scriptminsize_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scriptminsize_: *mut nsAtom; + #[link_name = "\x01?scriptsizemultiplier_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scriptsizemultiplier_: *mut nsAtom; + #[link_name = "\x01?scriptsize_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scriptsize_: *mut nsAtom; + #[link_name = "\x01?sdev_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sdev_: *mut nsAtom; + #[link_name = "\x01?sech_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sech_: *mut nsAtom; + #[link_name = "\x01?sec_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sec_: *mut nsAtom; + #[link_name = "\x01?selection_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_selection_: *mut nsAtom; + #[link_name = "\x01?selector_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_selector_: *mut nsAtom; + #[link_name = "\x01?semantics_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_semantics_: *mut nsAtom; + #[link_name = "\x01?separator_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_separator_: *mut nsAtom; + #[link_name = "\x01?separators_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_separators_: *mut nsAtom; + #[link_name = "\x01?sep_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sep_: *mut nsAtom; + #[link_name = "\x01?setdiff_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_setdiff_: *mut nsAtom; + #[link_name = "\x01?set_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_set_: *mut nsAtom; + #[link_name = "\x01?share_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_share_: *mut nsAtom; + #[link_name = "\x01?shift_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_shift_: *mut nsAtom; + #[link_name = "\x01?side_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_side_: *mut nsAtom; + #[link_name = "\x01?sinh_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sinh_: *mut nsAtom; + #[link_name = "\x01?sin_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sin_: *mut nsAtom; + #[link_name = "\x01?stackalign_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stackalign_: *mut nsAtom; + #[link_name = "\x01?stretchy_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stretchy_: *mut nsAtom; + #[link_name = "\x01?subscriptshift_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_subscriptshift_: *mut nsAtom; + #[link_name = "\x01?subset_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_subset_: *mut nsAtom; + #[link_name = "\x01?superscriptshift_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_superscriptshift_: *mut nsAtom; + #[link_name = "\x01?symmetric_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_symmetric_: *mut nsAtom; + #[link_name = "\x01?tanh_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tanh_: *mut nsAtom; + #[link_name = "\x01?tan_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tan_: *mut nsAtom; + #[link_name = "\x01?tendsto_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tendsto_: *mut nsAtom; + #[link_name = "\x01?times_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_times_: *mut nsAtom; + #[link_name = "\x01?transpose_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_transpose_: *mut nsAtom; + #[link_name = "\x01?union_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_union_: *mut nsAtom; + #[link_name = "\x01?uplimit_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_uplimit_: *mut nsAtom; + #[link_name = "\x01?variance_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_variance_: *mut nsAtom; + #[link_name = "\x01?vectorproduct_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_vectorproduct_: *mut nsAtom; + #[link_name = "\x01?vector_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_vector_: *mut nsAtom; + #[link_name = "\x01?voffset_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_voffset_: *mut nsAtom; + #[link_name = "\x01?xref_@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xref_: *mut nsAtom; + #[link_name = "\x01?math@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_math: *mut nsAtom; + #[link_name = "\x01?avg@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_avg: *mut nsAtom; + #[link_name = "\x01?booleanFromString@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_booleanFromString: *mut nsAtom; + #[link_name = "\x01?countNonEmpty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_countNonEmpty: *mut nsAtom; + #[link_name = "\x01?daysFromDate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_daysFromDate: *mut nsAtom; + #[link_name = "\x01?init@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_init: *mut nsAtom; + #[link_name = "\x01?instance@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_instance: *mut nsAtom; + #[link_name = "\x01?months@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_months: *mut nsAtom; + #[link_name = "\x01?now@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_now: *mut nsAtom; + #[link_name = "\x01?seconds@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_seconds: *mut nsAtom; + #[link_name = "\x01?secondsFromDateTime@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_secondsFromDateTime: *mut nsAtom; + #[link_name = "\x01?onMozSwipeGestureMayStart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onMozSwipeGestureMayStart: *mut nsAtom; + #[link_name = "\x01?onMozSwipeGestureStart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onMozSwipeGestureStart: *mut nsAtom; + #[link_name = "\x01?onMozSwipeGestureUpdate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onMozSwipeGestureUpdate: *mut nsAtom; + #[link_name = "\x01?onMozSwipeGestureEnd@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onMozSwipeGestureEnd: *mut nsAtom; + #[link_name = "\x01?onMozSwipeGesture@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onMozSwipeGesture: *mut nsAtom; + #[link_name = "\x01?onMozMagnifyGestureStart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onMozMagnifyGestureStart: *mut nsAtom; + #[link_name = "\x01?onMozMagnifyGestureUpdate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onMozMagnifyGestureUpdate: *mut nsAtom; + #[link_name = "\x01?onMozMagnifyGesture@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onMozMagnifyGesture: *mut nsAtom; + #[link_name = "\x01?onMozRotateGestureStart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onMozRotateGestureStart: *mut nsAtom; + #[link_name = "\x01?onMozRotateGestureUpdate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onMozRotateGestureUpdate: *mut nsAtom; + #[link_name = "\x01?onMozRotateGesture@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onMozRotateGesture: *mut nsAtom; + #[link_name = "\x01?onMozTapGesture@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onMozTapGesture: *mut nsAtom; + #[link_name = "\x01?onMozPressTapGesture@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onMozPressTapGesture: *mut nsAtom; + #[link_name = "\x01?onMozEdgeUIStarted@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onMozEdgeUIStarted: *mut nsAtom; + #[link_name = "\x01?onMozEdgeUICanceled@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onMozEdgeUICanceled: *mut nsAtom; + #[link_name = "\x01?onMozEdgeUICompleted@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onMozEdgeUICompleted: *mut nsAtom; + #[link_name = "\x01?onpointerdown@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpointerdown: *mut nsAtom; + #[link_name = "\x01?onpointermove@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpointermove: *mut nsAtom; + #[link_name = "\x01?onpointerup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpointerup: *mut nsAtom; + #[link_name = "\x01?onpointercancel@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpointercancel: *mut nsAtom; + #[link_name = "\x01?onpointerover@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpointerover: *mut nsAtom; + #[link_name = "\x01?onpointerout@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpointerout: *mut nsAtom; + #[link_name = "\x01?onpointerenter@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpointerenter: *mut nsAtom; + #[link_name = "\x01?onpointerleave@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpointerleave: *mut nsAtom; + #[link_name = "\x01?ongotpointercapture@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ongotpointercapture: *mut nsAtom; + #[link_name = "\x01?onlostpointercapture@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onlostpointercapture: *mut nsAtom; + #[link_name = "\x01?ondevicemotion@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondevicemotion: *mut nsAtom; + #[link_name = "\x01?ondeviceorientation@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondeviceorientation: *mut nsAtom; + #[link_name = "\x01?onabsolutedeviceorientation@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onabsolutedeviceorientation: *mut nsAtom; + #[link_name = "\x01?ondeviceproximity@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondeviceproximity: *mut nsAtom; + #[link_name = "\x01?onmozorientationchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmozorientationchange: *mut nsAtom; + #[link_name = "\x01?onuserproximity@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onuserproximity: *mut nsAtom; + #[link_name = "\x01?ondevicelight@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondevicelight: *mut nsAtom; + #[link_name = "\x01?ondevicechange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondevicechange: *mut nsAtom; + #[link_name = "\x01?mozinputrangeignorepreventdefault@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozinputrangeignorepreventdefault: *mut nsAtom; + #[link_name = "\x01?moz_extension@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_moz_extension: *mut nsAtom; + #[link_name = "\x01?all_urlsPermission@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_all_urlsPermission: *mut nsAtom; + #[link_name = "\x01?clipboardRead@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_clipboardRead: *mut nsAtom; + #[link_name = "\x01?clipboardWrite@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_clipboardWrite: *mut nsAtom; + #[link_name = "\x01?debugger@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_debugger: *mut nsAtom; + #[link_name = "\x01?tabs@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tabs: *mut nsAtom; + #[link_name = "\x01?webRequestBlocking@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_webRequestBlocking: *mut nsAtom; + #[link_name = "\x01?http@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_http: *mut nsAtom; + #[link_name = "\x01?https@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_https: *mut nsAtom; + #[link_name = "\x01?proxy@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_proxy: *mut nsAtom; + #[link_name = "\x01?cdataTagName@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cdataTagName: *mut nsAtom; + #[link_name = "\x01?commentTagName@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_commentTagName: *mut nsAtom; + #[link_name = "\x01?documentNodeName@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_documentNodeName: *mut nsAtom; + #[link_name = "\x01?documentFragmentNodeName@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_documentFragmentNodeName: *mut nsAtom; + #[link_name = "\x01?documentTypeNodeName@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_documentTypeNodeName: *mut nsAtom; + #[link_name = "\x01?processingInstructionTagName@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_processingInstructionTagName: *mut nsAtom; + #[link_name = "\x01?textTagName@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_textTagName: *mut nsAtom; + #[link_name = "\x01?placeholderFrame@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_placeholderFrame: *mut nsAtom; + #[link_name = "\x01?onloadend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onloadend: *mut nsAtom; + #[link_name = "\x01?onloadstart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onloadstart: *mut nsAtom; + #[link_name = "\x01?onprogress@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onprogress: *mut nsAtom; + #[link_name = "\x01?onsuspend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onsuspend: *mut nsAtom; + #[link_name = "\x01?onemptied@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onemptied: *mut nsAtom; + #[link_name = "\x01?onstalled@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onstalled: *mut nsAtom; + #[link_name = "\x01?onplay@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onplay: *mut nsAtom; + #[link_name = "\x01?onpause@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onpause: *mut nsAtom; + #[link_name = "\x01?onloadedmetadata@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onloadedmetadata: *mut nsAtom; + #[link_name = "\x01?onloadeddata@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onloadeddata: *mut nsAtom; + #[link_name = "\x01?onwaiting@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onwaiting: *mut nsAtom; + #[link_name = "\x01?onplaying@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onplaying: *mut nsAtom; + #[link_name = "\x01?oncanplay@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncanplay: *mut nsAtom; + #[link_name = "\x01?oncanplaythrough@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncanplaythrough: *mut nsAtom; + #[link_name = "\x01?onseeking@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onseeking: *mut nsAtom; + #[link_name = "\x01?onseeked@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onseeked: *mut nsAtom; + #[link_name = "\x01?ontimeout@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ontimeout: *mut nsAtom; + #[link_name = "\x01?ontimeupdate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ontimeupdate: *mut nsAtom; + #[link_name = "\x01?onended@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onended: *mut nsAtom; + #[link_name = "\x01?onratechange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onratechange: *mut nsAtom; + #[link_name = "\x01?ondurationchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondurationchange: *mut nsAtom; + #[link_name = "\x01?onvolumechange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onvolumechange: *mut nsAtom; + #[link_name = "\x01?onaddtrack@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onaddtrack: *mut nsAtom; + #[link_name = "\x01?oncontrollerchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncontrollerchange: *mut nsAtom; + #[link_name = "\x01?oncuechange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_oncuechange: *mut nsAtom; + #[link_name = "\x01?onenter@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onenter: *mut nsAtom; + #[link_name = "\x01?onexit@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onexit: *mut nsAtom; + #[link_name = "\x01?onencrypted@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onencrypted: *mut nsAtom; + #[link_name = "\x01?encrypted@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_encrypted: *mut nsAtom; + #[link_name = "\x01?onwaitingforkey@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onwaitingforkey: *mut nsAtom; + #[link_name = "\x01?onkeystatuseschange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onkeystatuseschange: *mut nsAtom; + #[link_name = "\x01?onremovetrack@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onremovetrack: *mut nsAtom; + #[link_name = "\x01?loadstart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_loadstart: *mut nsAtom; + #[link_name = "\x01?suspend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_suspend: *mut nsAtom; + #[link_name = "\x01?emptied@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_emptied: *mut nsAtom; + #[link_name = "\x01?stalled@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stalled: *mut nsAtom; + #[link_name = "\x01?play@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_play: *mut nsAtom; + #[link_name = "\x01?pause@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pause: *mut nsAtom; + #[link_name = "\x01?loadedmetadata@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_loadedmetadata: *mut nsAtom; + #[link_name = "\x01?loadeddata@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_loadeddata: *mut nsAtom; + #[link_name = "\x01?waiting@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_waiting: *mut nsAtom; + #[link_name = "\x01?playing@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_playing: *mut nsAtom; + #[link_name = "\x01?seeking@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_seeking: *mut nsAtom; + #[link_name = "\x01?seeked@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_seeked: *mut nsAtom; + #[link_name = "\x01?timeupdate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_timeupdate: *mut nsAtom; + #[link_name = "\x01?ended@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ended: *mut nsAtom; + #[link_name = "\x01?canplay@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_canplay: *mut nsAtom; + #[link_name = "\x01?canplaythrough@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_canplaythrough: *mut nsAtom; + #[link_name = "\x01?ratechange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ratechange: *mut nsAtom; + #[link_name = "\x01?durationchange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_durationchange: *mut nsAtom; + #[link_name = "\x01?volumechange@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_volumechange: *mut nsAtom; + #[link_name = "\x01?ondataavailable@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ondataavailable: *mut nsAtom; + #[link_name = "\x01?onwarning@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onwarning: *mut nsAtom; + #[link_name = "\x01?onstart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onstart: *mut nsAtom; + #[link_name = "\x01?onstop@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onstop: *mut nsAtom; + #[link_name = "\x01?onphoto@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onphoto: *mut nsAtom; + #[link_name = "\x01?onactivestatechanged@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onactivestatechanged: *mut nsAtom; + #[link_name = "\x01?ongamepadbuttondown@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ongamepadbuttondown: *mut nsAtom; + #[link_name = "\x01?ongamepadbuttonup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ongamepadbuttonup: *mut nsAtom; + #[link_name = "\x01?ongamepadaxismove@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ongamepadaxismove: *mut nsAtom; + #[link_name = "\x01?ongamepadconnected@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ongamepadconnected: *mut nsAtom; + #[link_name = "\x01?ongamepaddisconnected@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ongamepaddisconnected: *mut nsAtom; + #[link_name = "\x01?afterPseudoProperty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_afterPseudoProperty: *mut nsAtom; + #[link_name = "\x01?animationsProperty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_animationsProperty: *mut nsAtom; + #[link_name = "\x01?animationsOfBeforeProperty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_animationsOfBeforeProperty: *mut nsAtom; + #[link_name = "\x01?animationsOfAfterProperty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_animationsOfAfterProperty: *mut nsAtom; + #[link_name = "\x01?animationEffectsProperty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_animationEffectsProperty: *mut nsAtom; + #[link_name = "\x01?animationEffectsForBeforeProperty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_animationEffectsForBeforeProperty: *mut nsAtom; + #[link_name = "\x01?animationEffectsForAfterProperty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_animationEffectsForAfterProperty: *mut nsAtom; + #[link_name = "\x01?beforePseudoProperty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_beforePseudoProperty: *mut nsAtom; + #[link_name = "\x01?cssPseudoElementBeforeProperty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cssPseudoElementBeforeProperty: *mut nsAtom; + #[link_name = "\x01?cssPseudoElementAfterProperty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cssPseudoElementAfterProperty: *mut nsAtom; + #[link_name = "\x01?transitionsProperty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_transitionsProperty: *mut nsAtom; + #[link_name = "\x01?transitionsOfBeforeProperty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_transitionsOfBeforeProperty: *mut nsAtom; + #[link_name = "\x01?transitionsOfAfterProperty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_transitionsOfAfterProperty: *mut nsAtom; + #[link_name = "\x01?genConInitializerProperty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_genConInitializerProperty: *mut nsAtom; + #[link_name = "\x01?labelMouseDownPtProperty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_labelMouseDownPtProperty: *mut nsAtom; + #[link_name = "\x01?lockedStyleStates@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lockedStyleStates: *mut nsAtom; + #[link_name = "\x01?apzCallbackTransform@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_apzCallbackTransform: *mut nsAtom; + #[link_name = "\x01?restylableAnonymousNode@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_restylableAnonymousNode: *mut nsAtom; + #[link_name = "\x01?paintRequestTime@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_paintRequestTime: *mut nsAtom; + #[link_name = "\x01?pseudoProperty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pseudoProperty: *mut nsAtom; + #[link_name = "\x01?manualNACProperty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_manualNACProperty: *mut nsAtom; + #[link_name = "\x01?Japanese@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_Japanese: *mut nsAtom; + #[link_name = "\x01?Chinese@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_Chinese: *mut nsAtom; + #[link_name = "\x01?Taiwanese@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_Taiwanese: *mut nsAtom; + #[link_name = "\x01?HongKongChinese@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_HongKongChinese: *mut nsAtom; + #[link_name = "\x01?Unicode@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_Unicode: *mut nsAtom; + #[link_name = "\x01?ko@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ko: *mut nsAtom; + #[link_name = "\x01?zh_cn@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_zh_cn: *mut nsAtom; + #[link_name = "\x01?zh_hk@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_zh_hk: *mut nsAtom; + #[link_name = "\x01?zh_tw@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_zh_tw: *mut nsAtom; + #[link_name = "\x01?x_cyrillic@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x_cyrillic: *mut nsAtom; + #[link_name = "\x01?he@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_he: *mut nsAtom; + #[link_name = "\x01?ar@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ar: *mut nsAtom; + #[link_name = "\x01?x_devanagari@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x_devanagari: *mut nsAtom; + #[link_name = "\x01?x_tamil@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x_tamil: *mut nsAtom; + #[link_name = "\x01?x_armn@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x_armn: *mut nsAtom; + #[link_name = "\x01?x_beng@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x_beng: *mut nsAtom; + #[link_name = "\x01?x_cans@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x_cans: *mut nsAtom; + #[link_name = "\x01?x_ethi@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x_ethi: *mut nsAtom; + #[link_name = "\x01?x_geor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x_geor: *mut nsAtom; + #[link_name = "\x01?x_gujr@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x_gujr: *mut nsAtom; + #[link_name = "\x01?x_guru@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x_guru: *mut nsAtom; + #[link_name = "\x01?x_khmr@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x_khmr: *mut nsAtom; + #[link_name = "\x01?x_knda@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x_knda: *mut nsAtom; + #[link_name = "\x01?x_mlym@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x_mlym: *mut nsAtom; + #[link_name = "\x01?x_orya@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x_orya: *mut nsAtom; + #[link_name = "\x01?x_sinh@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x_sinh: *mut nsAtom; + #[link_name = "\x01?x_telu@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x_telu: *mut nsAtom; + #[link_name = "\x01?x_tibt@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x_tibt: *mut nsAtom; + #[link_name = "\x01?az@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_az: *mut nsAtom; + #[link_name = "\x01?ba@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ba: *mut nsAtom; + #[link_name = "\x01?crh@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_crh: *mut nsAtom; + #[link_name = "\x01?el@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_el: *mut nsAtom; + #[link_name = "\x01?ga@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ga: *mut nsAtom; + #[link_name = "\x01?nl@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nl: *mut nsAtom; + #[link_name = "\x01?x_math@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_x_math: *mut nsAtom; + #[link_name = "\x01?TypingTxnName@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_TypingTxnName: *mut nsAtom; + #[link_name = "\x01?IMETxnName@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_IMETxnName: *mut nsAtom; + #[link_name = "\x01?DeleteTxnName@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_DeleteTxnName: *mut nsAtom; + #[link_name = "\x01?serif@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_serif: *mut nsAtom; + #[link_name = "\x01?sans_serif@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_sans_serif: *mut nsAtom; + #[link_name = "\x01?cursive@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cursive: *mut nsAtom; + #[link_name = "\x01?fantasy@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fantasy: *mut nsAtom; + #[link_name = "\x01?monospace@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_monospace: *mut nsAtom; + #[link_name = "\x01?mozfixed@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mozfixed: *mut nsAtom; + #[link_name = "\x01?Remote@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_Remote: *mut nsAtom; + #[link_name = "\x01?RemoteId@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_RemoteId: *mut nsAtom; + #[link_name = "\x01?RemoteType@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_RemoteType: *mut nsAtom; + #[link_name = "\x01?DisplayPort@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_DisplayPort: *mut nsAtom; + #[link_name = "\x01?DisplayPortMargins@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_DisplayPortMargins: *mut nsAtom; + #[link_name = "\x01?DisplayPortBase@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_DisplayPortBase: *mut nsAtom; + #[link_name = "\x01?AsyncScrollLayerCreationFailed@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_AsyncScrollLayerCreationFailed: *mut nsAtom; + #[link_name = "\x01?forcemessagemanager@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_forcemessagemanager: *mut nsAtom; + #[link_name = "\x01?isPreloadBrowser@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_isPreloadBrowser: *mut nsAtom; + #[link_name = "\x01?color_picker_available@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_color_picker_available: *mut nsAtom; + #[link_name = "\x01?scrollbar_start_backward@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scrollbar_start_backward: *mut nsAtom; + #[link_name = "\x01?scrollbar_start_forward@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scrollbar_start_forward: *mut nsAtom; + #[link_name = "\x01?scrollbar_end_backward@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scrollbar_end_backward: *mut nsAtom; + #[link_name = "\x01?scrollbar_end_forward@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scrollbar_end_forward: *mut nsAtom; + #[link_name = "\x01?scrollbar_thumb_proportional@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scrollbar_thumb_proportional: *mut nsAtom; + #[link_name = "\x01?overlay_scrollbars@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_overlay_scrollbars: *mut nsAtom; + #[link_name = "\x01?windows_accent_color_in_titlebar@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_windows_accent_color_in_titlebar: *mut nsAtom; + #[link_name = "\x01?windows_default_theme@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_windows_default_theme: *mut nsAtom; + #[link_name = "\x01?mac_graphite_theme@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mac_graphite_theme: *mut nsAtom; + #[link_name = "\x01?mac_yosemite_theme@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mac_yosemite_theme: *mut nsAtom; + #[link_name = "\x01?windows_compositor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_windows_compositor: *mut nsAtom; + #[link_name = "\x01?windows_glass@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_windows_glass: *mut nsAtom; + #[link_name = "\x01?touch_enabled@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_touch_enabled: *mut nsAtom; + #[link_name = "\x01?menubar_drag@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_menubar_drag: *mut nsAtom; + #[link_name = "\x01?swipe_animation_enabled@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_swipe_animation_enabled: *mut nsAtom; + #[link_name = "\x01?physical_home_button@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_physical_home_button: *mut nsAtom; + #[link_name = "\x01?windows_classic@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_windows_classic: *mut nsAtom; + #[link_name = "\x01?windows_theme_aero@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_windows_theme_aero: *mut nsAtom; + #[link_name = "\x01?windows_theme_aero_lite@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_windows_theme_aero_lite: *mut nsAtom; + #[link_name = "\x01?windows_theme_luna_blue@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_windows_theme_luna_blue: *mut nsAtom; + #[link_name = "\x01?windows_theme_luna_olive@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_windows_theme_luna_olive: *mut nsAtom; + #[link_name = "\x01?windows_theme_luna_silver@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_windows_theme_luna_silver: *mut nsAtom; + #[link_name = "\x01?windows_theme_royale@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_windows_theme_royale: *mut nsAtom; + #[link_name = "\x01?windows_theme_zune@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_windows_theme_zune: *mut nsAtom; + #[link_name = "\x01?windows_theme_generic@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_windows_theme_generic: *mut nsAtom; + #[link_name = "\x01?_moz_color_picker_available@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_color_picker_available: *mut nsAtom; + #[link_name = "\x01?_moz_scrollbar_start_backward@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_scrollbar_start_backward: *mut nsAtom; + #[link_name = "\x01?_moz_scrollbar_start_forward@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_scrollbar_start_forward: *mut nsAtom; + #[link_name = "\x01?_moz_scrollbar_end_backward@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_scrollbar_end_backward: *mut nsAtom; + #[link_name = "\x01?_moz_scrollbar_end_forward@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_scrollbar_end_forward: *mut nsAtom; + #[link_name = "\x01?_moz_scrollbar_thumb_proportional@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_scrollbar_thumb_proportional: *mut nsAtom; + #[link_name = "\x01?_moz_overlay_scrollbars@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_overlay_scrollbars: *mut nsAtom; + #[link_name = "\x01?_moz_windows_accent_color_in_titlebar@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_windows_accent_color_in_titlebar: *mut nsAtom; + #[link_name = "\x01?_moz_windows_default_theme@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_windows_default_theme: *mut nsAtom; + #[link_name = "\x01?_moz_mac_graphite_theme@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_mac_graphite_theme: *mut nsAtom; + #[link_name = "\x01?_moz_mac_yosemite_theme@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_mac_yosemite_theme: *mut nsAtom; + #[link_name = "\x01?_moz_windows_compositor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_windows_compositor: *mut nsAtom; + #[link_name = "\x01?_moz_windows_classic@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_windows_classic: *mut nsAtom; + #[link_name = "\x01?_moz_windows_glass@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_windows_glass: *mut nsAtom; + #[link_name = "\x01?_moz_windows_theme@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_windows_theme: *mut nsAtom; + #[link_name = "\x01?_moz_os_version@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_os_version: *mut nsAtom; + #[link_name = "\x01?_moz_touch_enabled@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_touch_enabled: *mut nsAtom; + #[link_name = "\x01?_moz_menubar_drag@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_menubar_drag: *mut nsAtom; + #[link_name = "\x01?_moz_device_pixel_ratio@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_device_pixel_ratio: *mut nsAtom; + #[link_name = "\x01?_moz_device_orientation@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_device_orientation: *mut nsAtom; + #[link_name = "\x01?_moz_is_resource_document@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_is_resource_document: *mut nsAtom; + #[link_name = "\x01?_moz_swipe_animation_enabled@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_swipe_animation_enabled: *mut nsAtom; + #[link_name = "\x01?_moz_physical_home_button@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__moz_physical_home_button: *mut nsAtom; + #[link_name = "\x01?Back@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_Back: *mut nsAtom; + #[link_name = "\x01?Forward@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_Forward: *mut nsAtom; + #[link_name = "\x01?Reload@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_Reload: *mut nsAtom; + #[link_name = "\x01?Stop@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_Stop: *mut nsAtom; + #[link_name = "\x01?Search@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_Search: *mut nsAtom; + #[link_name = "\x01?Bookmarks@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_Bookmarks: *mut nsAtom; + #[link_name = "\x01?Home@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_Home: *mut nsAtom; + #[link_name = "\x01?Clear@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_Clear: *mut nsAtom; + #[link_name = "\x01?VolumeUp@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_VolumeUp: *mut nsAtom; + #[link_name = "\x01?VolumeDown@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_VolumeDown: *mut nsAtom; + #[link_name = "\x01?NextTrack@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_NextTrack: *mut nsAtom; + #[link_name = "\x01?PreviousTrack@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_PreviousTrack: *mut nsAtom; + #[link_name = "\x01?MediaStop@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_MediaStop: *mut nsAtom; + #[link_name = "\x01?PlayPause@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_PlayPause: *mut nsAtom; + #[link_name = "\x01?Menu@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_Menu: *mut nsAtom; + #[link_name = "\x01?New@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_New: *mut nsAtom; + #[link_name = "\x01?Open@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_Open: *mut nsAtom; + #[link_name = "\x01?Close@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_Close: *mut nsAtom; + #[link_name = "\x01?Save@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_Save: *mut nsAtom; + #[link_name = "\x01?Find@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_Find: *mut nsAtom; + #[link_name = "\x01?Help@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_Help: *mut nsAtom; + #[link_name = "\x01?Print@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_Print: *mut nsAtom; + #[link_name = "\x01?SendMail@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_SendMail: *mut nsAtom; + #[link_name = "\x01?ForwardMail@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ForwardMail: *mut nsAtom; + #[link_name = "\x01?ReplyToMail@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ReplyToMail: *mut nsAtom; + #[link_name = "\x01?mouseWheel@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mouseWheel: *mut nsAtom; + #[link_name = "\x01?pixels@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pixels: *mut nsAtom; + #[link_name = "\x01?lines@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lines: *mut nsAtom; + #[link_name = "\x01?pages@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pages: *mut nsAtom; + #[link_name = "\x01?scrollbars@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_scrollbars: *mut nsAtom; + #[link_name = "\x01?other@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_other: *mut nsAtom; + #[link_name = "\x01?apz@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_apz: *mut nsAtom; + #[link_name = "\x01?restore@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_restore: *mut nsAtom; + #[link_name = "\x01?alert@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_alert: *mut nsAtom; + #[link_name = "\x01?alertdialog@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_alertdialog: *mut nsAtom; + #[link_name = "\x01?application@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_application: *mut nsAtom; + #[link_name = "\x01?aria_colcount@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_colcount: *mut nsAtom; + #[link_name = "\x01?aria_colindex@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_colindex: *mut nsAtom; + #[link_name = "\x01?aria_details@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_details: *mut nsAtom; + #[link_name = "\x01?aria_errormessage@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_errormessage: *mut nsAtom; + #[link_name = "\x01?aria_grabbed@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_grabbed: *mut nsAtom; + #[link_name = "\x01?aria_label@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_label: *mut nsAtom; + #[link_name = "\x01?aria_modal@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_modal: *mut nsAtom; + #[link_name = "\x01?aria_orientation@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_orientation: *mut nsAtom; + #[link_name = "\x01?aria_rowcount@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_rowcount: *mut nsAtom; + #[link_name = "\x01?aria_rowindex@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_rowindex: *mut nsAtom; + #[link_name = "\x01?aria_valuetext@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_valuetext: *mut nsAtom; + #[link_name = "\x01?auto_generated@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_auto_generated: *mut nsAtom; + #[link_name = "\x01?banner@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_banner: *mut nsAtom; + #[link_name = "\x01?checkable@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_checkable: *mut nsAtom; + #[link_name = "\x01?choices@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_choices: *mut nsAtom; + #[link_name = "\x01?columnheader@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_columnheader: *mut nsAtom; + #[link_name = "\x01?complementary@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_complementary: *mut nsAtom; + #[link_name = "\x01?containerAtomic@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_containerAtomic: *mut nsAtom; + #[link_name = "\x01?containerBusy@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_containerBusy: *mut nsAtom; + #[link_name = "\x01?containerLive@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_containerLive: *mut nsAtom; + #[link_name = "\x01?containerLiveRole@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_containerLiveRole: *mut nsAtom; + #[link_name = "\x01?containerRelevant@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_containerRelevant: *mut nsAtom; + #[link_name = "\x01?contentinfo@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_contentinfo: *mut nsAtom; + #[link_name = "\x01?cycles@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_cycles: *mut nsAtom; + #[link_name = "\x01?datatable@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_datatable: *mut nsAtom; + #[link_name = "\x01?eventFromInput@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_eventFromInput: *mut nsAtom; + #[link_name = "\x01?feed@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feed: *mut nsAtom; + #[link_name = "\x01?grammar@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_grammar: *mut nsAtom; + #[link_name = "\x01?gridcell@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_gridcell: *mut nsAtom; + #[link_name = "\x01?heading@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_heading: *mut nsAtom; + #[link_name = "\x01?hitregion@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_hitregion: *mut nsAtom; + #[link_name = "\x01?inlinevalue@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_inlinevalue: *mut nsAtom; + #[link_name = "\x01?invalid@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_invalid: *mut nsAtom; + #[link_name = "\x01?item@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_item: *mut nsAtom; + #[link_name = "\x01?itemset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_itemset: *mut nsAtom; + #[link_name = "\x01?lineNumber@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lineNumber: *mut nsAtom; + #[link_name = "\x01?linkedPanel@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_linkedPanel: *mut nsAtom; + #[link_name = "\x01?live@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_live: *mut nsAtom; + #[link_name = "\x01?menuitemcheckbox@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_menuitemcheckbox: *mut nsAtom; + #[link_name = "\x01?menuitemradio@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_menuitemradio: *mut nsAtom; + #[link_name = "\x01?mixed@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_mixed: *mut nsAtom; + #[link_name = "\x01?multiline@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_multiline: *mut nsAtom; + #[link_name = "\x01?navigation@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_navigation: *mut nsAtom; + #[link_name = "\x01?polite@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_polite: *mut nsAtom; + #[link_name = "\x01?posinset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_posinset: *mut nsAtom; + #[link_name = "\x01?presentation@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_presentation: *mut nsAtom; + #[link_name = "\x01?progressbar@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_progressbar: *mut nsAtom; + #[link_name = "\x01?region@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_region: *mut nsAtom; + #[link_name = "\x01?rowgroup@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rowgroup: *mut nsAtom; + #[link_name = "\x01?rowheader@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rowheader: *mut nsAtom; + #[link_name = "\x01?search@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_search: *mut nsAtom; + #[link_name = "\x01?searchbox@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_searchbox: *mut nsAtom; + #[link_name = "\x01?select1@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_select1: *mut nsAtom; + #[link_name = "\x01?setsize@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_setsize: *mut nsAtom; + #[link_name = "\x01?spelling@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_spelling: *mut nsAtom; + #[link_name = "\x01?spinbutton@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_spinbutton: *mut nsAtom; + #[link_name = "\x01?status@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_status: *mut nsAtom; + #[link_name = "\x01?tableCellIndex@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tableCellIndex: *mut nsAtom; + #[link_name = "\x01?tablist@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tablist: *mut nsAtom; + #[link_name = "\x01?textIndent@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_textIndent: *mut nsAtom; + #[link_name = "\x01?textInputType@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_textInputType: *mut nsAtom; + #[link_name = "\x01?textLineThroughColor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_textLineThroughColor: *mut nsAtom; + #[link_name = "\x01?textLineThroughStyle@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_textLineThroughStyle: *mut nsAtom; + #[link_name = "\x01?textPosition@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_textPosition: *mut nsAtom; + #[link_name = "\x01?textUnderlineColor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_textUnderlineColor: *mut nsAtom; + #[link_name = "\x01?textUnderlineStyle@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_textUnderlineStyle: *mut nsAtom; + #[link_name = "\x01?timer@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_timer: *mut nsAtom; + #[link_name = "\x01?toolbarname@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_toolbarname: *mut nsAtom; + #[link_name = "\x01?toolbarseparator@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_toolbarseparator: *mut nsAtom; + #[link_name = "\x01?toolbarspacer@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_toolbarspacer: *mut nsAtom; + #[link_name = "\x01?toolbarspring@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_toolbarspring: *mut nsAtom; + #[link_name = "\x01?treegrid@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_treegrid: *mut nsAtom; + #[link_name = "\x01?_undefined@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms__undefined: *mut nsAtom; + #[link_name = "\x01?xmlroles@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xmlroles: *mut nsAtom; + #[link_name = "\x01?close_fence@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_close_fence: *mut nsAtom; + #[link_name = "\x01?denominator@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_denominator: *mut nsAtom; + #[link_name = "\x01?numerator@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_numerator: *mut nsAtom; + #[link_name = "\x01?open_fence@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_open_fence: *mut nsAtom; + #[link_name = "\x01?overscript@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_overscript: *mut nsAtom; + #[link_name = "\x01?presubscript@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_presubscript: *mut nsAtom; + #[link_name = "\x01?presuperscript@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_presuperscript: *mut nsAtom; + #[link_name = "\x01?root_index@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_root_index: *mut nsAtom; + #[link_name = "\x01?subscript@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_subscript: *mut nsAtom; + #[link_name = "\x01?superscript@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_superscript: *mut nsAtom; + #[link_name = "\x01?underscript@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_underscript: *mut nsAtom; + #[link_name = "\x01?onaudiostart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onaudiostart: *mut nsAtom; + #[link_name = "\x01?onaudioend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onaudioend: *mut nsAtom; + #[link_name = "\x01?onsoundstart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onsoundstart: *mut nsAtom; + #[link_name = "\x01?onsoundend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onsoundend: *mut nsAtom; + #[link_name = "\x01?onspeechstart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onspeechstart: *mut nsAtom; + #[link_name = "\x01?onspeechend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onspeechend: *mut nsAtom; + #[link_name = "\x01?onresult@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onresult: *mut nsAtom; + #[link_name = "\x01?onnomatch@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onnomatch: *mut nsAtom; + #[link_name = "\x01?onresume@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onresume: *mut nsAtom; + #[link_name = "\x01?onmark@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmark: *mut nsAtom; + #[link_name = "\x01?onboundary@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onboundary: *mut nsAtom; + #[link_name = "\x01?usercontextid@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_usercontextid: *mut nsAtom; + #[link_name = "\x01?nsuri_xmlns@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nsuri_xmlns: *mut nsAtom; + #[link_name = "\x01?nsuri_xml@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nsuri_xml: *mut nsAtom; + #[link_name = "\x01?nsuri_xhtml@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nsuri_xhtml: *mut nsAtom; + #[link_name = "\x01?nsuri_xlink@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nsuri_xlink: *mut nsAtom; + #[link_name = "\x01?nsuri_xslt@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nsuri_xslt: *mut nsAtom; + #[link_name = "\x01?nsuri_xbl@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nsuri_xbl: *mut nsAtom; + #[link_name = "\x01?nsuri_mathml@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nsuri_mathml: *mut nsAtom; + #[link_name = "\x01?nsuri_rdf@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nsuri_rdf: *mut nsAtom; + #[link_name = "\x01?nsuri_xul@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nsuri_xul: *mut nsAtom; + #[link_name = "\x01?nsuri_svg@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_nsuri_svg: *mut nsAtom; + #[link_name = "\x01?onsourceopen@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onsourceopen: *mut nsAtom; + #[link_name = "\x01?onsourceended@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onsourceended: *mut nsAtom; + #[link_name = "\x01?onsourceclosed@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onsourceclosed: *mut nsAtom; + #[link_name = "\x01?onupdatestart@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onupdatestart: *mut nsAtom; + #[link_name = "\x01?onupdate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onupdate: *mut nsAtom; + #[link_name = "\x01?onupdateend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onupdateend: *mut nsAtom; + #[link_name = "\x01?onaddsourcebuffer@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onaddsourcebuffer: *mut nsAtom; + #[link_name = "\x01?onremovesourcebuffer@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onremovesourcebuffer: *mut nsAtom; + #[link_name = "\x01?xlink@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xlink: *mut nsAtom; + #[link_name = "\x01?xml_space@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xml_space: *mut nsAtom; + #[link_name = "\x01?xml_lang@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xml_lang: *mut nsAtom; + #[link_name = "\x01?xml_base@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xml_base: *mut nsAtom; + #[link_name = "\x01?aria_grab@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_grab: *mut nsAtom; + #[link_name = "\x01?aria_channel@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_channel: *mut nsAtom; + #[link_name = "\x01?aria_secret@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_secret: *mut nsAtom; + #[link_name = "\x01?aria_templateid@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_templateid: *mut nsAtom; + #[link_name = "\x01?aria_datatype@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_aria_datatype: *mut nsAtom; + #[link_name = "\x01?local@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_local: *mut nsAtom; + #[link_name = "\x01?xchannelselector@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xchannelselector: *mut nsAtom; + #[link_name = "\x01?ychannelselector@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_ychannelselector: *mut nsAtom; + #[link_name = "\x01?enable_background@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_enable_background: *mut nsAtom; + #[link_name = "\x01?calcmode@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_calcmode: *mut nsAtom; + #[link_name = "\x01?specularexponent@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_specularexponent: *mut nsAtom; + #[link_name = "\x01?specularconstant@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_specularconstant: *mut nsAtom; + #[link_name = "\x01?gradienttransform@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_gradienttransform: *mut nsAtom; + #[link_name = "\x01?gradientunits@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_gradientunits: *mut nsAtom; + #[link_name = "\x01?rendering_intent@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_rendering_intent: *mut nsAtom; + #[link_name = "\x01?stddeviation@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stddeviation: *mut nsAtom; + #[link_name = "\x01?basefrequency@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_basefrequency: *mut nsAtom; + #[link_name = "\x01?baseprofile@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_baseprofile: *mut nsAtom; + #[link_name = "\x01?baseProfile@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_baseProfile: *mut nsAtom; + #[link_name = "\x01?edgemode@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_edgemode: *mut nsAtom; + #[link_name = "\x01?repeatcount@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_repeatcount: *mut nsAtom; + #[link_name = "\x01?repeatdur@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_repeatdur: *mut nsAtom; + #[link_name = "\x01?spreadmethod@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_spreadmethod: *mut nsAtom; + #[link_name = "\x01?diffuseconstant@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_diffuseconstant: *mut nsAtom; + #[link_name = "\x01?surfacescale@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_surfacescale: *mut nsAtom; + #[link_name = "\x01?lengthadjust@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lengthadjust: *mut nsAtom; + #[link_name = "\x01?origin@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_origin: *mut nsAtom; + #[link_name = "\x01?targetx@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_targetx: *mut nsAtom; + #[link_name = "\x01?targety@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_targety: *mut nsAtom; + #[link_name = "\x01?pathlength@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pathlength: *mut nsAtom; + #[link_name = "\x01?definitionurl@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_definitionurl: *mut nsAtom; + #[link_name = "\x01?limitingconeangle@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_limitingconeangle: *mut nsAtom; + #[link_name = "\x01?markerheight@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_markerheight: *mut nsAtom; + #[link_name = "\x01?markerwidth@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_markerwidth: *mut nsAtom; + #[link_name = "\x01?maskunits@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_maskunits: *mut nsAtom; + #[link_name = "\x01?markerunits@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_markerunits: *mut nsAtom; + #[link_name = "\x01?maskcontentunits@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_maskcontentunits: *mut nsAtom; + #[link_name = "\x01?tablevalues@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_tablevalues: *mut nsAtom; + #[link_name = "\x01?primitiveunits@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_primitiveunits: *mut nsAtom; + #[link_name = "\x01?zoomandpan@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_zoomandpan: *mut nsAtom; + #[link_name = "\x01?kernelmatrix@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_kernelmatrix: *mut nsAtom; + #[link_name = "\x01?kerning@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_kerning: *mut nsAtom; + #[link_name = "\x01?kernelunitlength@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_kernelunitlength: *mut nsAtom; + #[link_name = "\x01?pointsatx@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pointsatx: *mut nsAtom; + #[link_name = "\x01?pointsaty@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pointsaty: *mut nsAtom; + #[link_name = "\x01?pointsatz@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_pointsatz: *mut nsAtom; + #[link_name = "\x01?xlink_href@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xlink_href: *mut nsAtom; + #[link_name = "\x01?xlink_title@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xlink_title: *mut nsAtom; + #[link_name = "\x01?xlink_role@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xlink_role: *mut nsAtom; + #[link_name = "\x01?xlink_arcrole@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xlink_arcrole: *mut nsAtom; + #[link_name = "\x01?arcrole@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_arcrole: *mut nsAtom; + #[link_name = "\x01?xmlns_xlink@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xmlns_xlink: *mut nsAtom; + #[link_name = "\x01?xlink_type@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xlink_type: *mut nsAtom; + #[link_name = "\x01?xlink_show@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xlink_show: *mut nsAtom; + #[link_name = "\x01?xlink_actuate@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_xlink_actuate: *mut nsAtom; + #[link_name = "\x01?color_rendering@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_color_rendering: *mut nsAtom; + #[link_name = "\x01?numoctaves@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_numoctaves: *mut nsAtom; + #[link_name = "\x01?onmousewheel@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_onmousewheel: *mut nsAtom; + #[link_name = "\x01?clippathunits@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_clippathunits: *mut nsAtom; + #[link_name = "\x01?glyph_orientation_vertical@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_glyph_orientation_vertical: *mut nsAtom; + #[link_name = "\x01?glyph_orientation_horizontal@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_glyph_orientation_horizontal: *mut nsAtom; + #[link_name = "\x01?glyphref@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_glyphref: *mut nsAtom; + #[link_name = "\x01?keypoints@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_keypoints: *mut nsAtom; + #[link_name = "\x01?attributename@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_attributename: *mut nsAtom; + #[link_name = "\x01?attributetype@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_attributetype: *mut nsAtom; + #[link_name = "\x01?startoffset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_startoffset: *mut nsAtom; + #[link_name = "\x01?keysplines@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_keysplines: *mut nsAtom; + #[link_name = "\x01?preservealpha@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_preservealpha: *mut nsAtom; + #[link_name = "\x01?preserveaspectratio@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_preserveaspectratio: *mut nsAtom; + #[link_name = "\x01?alttext@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_alttext: *mut nsAtom; + #[link_name = "\x01?filterunits@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_filterunits: *mut nsAtom; + #[link_name = "\x01?keytimes@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_keytimes: *mut nsAtom; + #[link_name = "\x01?patterntransform@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_patterntransform: *mut nsAtom; + #[link_name = "\x01?patternunits@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_patternunits: *mut nsAtom; + #[link_name = "\x01?patterncontentunits@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_patterncontentunits: *mut nsAtom; + #[link_name = "\x01?stitchtiles@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_stitchtiles: *mut nsAtom; + #[link_name = "\x01?systemlanguage@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_systemlanguage: *mut nsAtom; + #[link_name = "\x01?textlength@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_textlength: *mut nsAtom; + #[link_name = "\x01?requiredfeatures@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_requiredfeatures: *mut nsAtom; + #[link_name = "\x01?requiredextensions@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_requiredextensions: *mut nsAtom; + #[link_name = "\x01?viewtarget@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_viewtarget: *mut nsAtom; + #[link_name = "\x01?viewbox@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_viewbox: *mut nsAtom; + #[link_name = "\x01?refx@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_refx: *mut nsAtom; + #[link_name = "\x01?refy@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_refy: *mut nsAtom; + #[link_name = "\x01?fefunca@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fefunca: *mut nsAtom; + #[link_name = "\x01?fefuncb@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fefuncb: *mut nsAtom; + #[link_name = "\x01?feblend@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feblend: *mut nsAtom; + #[link_name = "\x01?feflood@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feflood: *mut nsAtom; + #[link_name = "\x01?feturbulence@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feturbulence: *mut nsAtom; + #[link_name = "\x01?femergenode@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_femergenode: *mut nsAtom; + #[link_name = "\x01?feimage@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feimage: *mut nsAtom; + #[link_name = "\x01?femerge@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_femerge: *mut nsAtom; + #[link_name = "\x01?fetile@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fetile: *mut nsAtom; + #[link_name = "\x01?fecomposite@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fecomposite: *mut nsAtom; + #[link_name = "\x01?altglyphdef@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_altglyphdef: *mut nsAtom; + #[link_name = "\x01?altGlyphDef@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_altGlyphDef: *mut nsAtom; + #[link_name = "\x01?fefuncg@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fefuncg: *mut nsAtom; + #[link_name = "\x01?fediffuselighting@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fediffuselighting: *mut nsAtom; + #[link_name = "\x01?fespecularlighting@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fespecularlighting: *mut nsAtom; + #[link_name = "\x01?altglyph@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_altglyph: *mut nsAtom; + #[link_name = "\x01?altGlyph@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_altGlyph: *mut nsAtom; + #[link_name = "\x01?clippath@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_clippath: *mut nsAtom; + #[link_name = "\x01?textpath@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_textpath: *mut nsAtom; + #[link_name = "\x01?altglyphitem@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_altglyphitem: *mut nsAtom; + #[link_name = "\x01?altGlyphItem@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_altGlyphItem: *mut nsAtom; + #[link_name = "\x01?animatetransform@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_animatetransform: *mut nsAtom; + #[link_name = "\x01?animatemotion@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_animatemotion: *mut nsAtom; + #[link_name = "\x01?fedisplacementmap@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fedisplacementmap: *mut nsAtom; + #[link_name = "\x01?animatecolor@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_animatecolor: *mut nsAtom; + #[link_name = "\x01?fefuncr@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fefuncr: *mut nsAtom; + #[link_name = "\x01?fecomponenttransfer@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fecomponenttransfer: *mut nsAtom; + #[link_name = "\x01?fegaussianblur@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fegaussianblur: *mut nsAtom; + #[link_name = "\x01?foreignobject@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_foreignobject: *mut nsAtom; + #[link_name = "\x01?feoffset@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feoffset: *mut nsAtom; + #[link_name = "\x01?fespotlight@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fespotlight: *mut nsAtom; + #[link_name = "\x01?fepointlight@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fepointlight: *mut nsAtom; + #[link_name = "\x01?fedistantlight@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fedistantlight: *mut nsAtom; + #[link_name = "\x01?lineargradient@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_lineargradient: *mut nsAtom; + #[link_name = "\x01?radialgradient@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_radialgradient: *mut nsAtom; + #[link_name = "\x01?fedropshadow@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fedropshadow: *mut nsAtom; + #[link_name = "\x01?fecolormatrix@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_fecolormatrix: *mut nsAtom; + #[link_name = "\x01?feconvolvematrix@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_feconvolvematrix: *mut nsAtom; + #[link_name = "\x01?femorphology@nsGkAtoms@@2PAVnsAtom@@A"] + pub static nsGkAtoms_femorphology: *mut nsAtom; #[link_name = "\x01?after@nsCSSPseudoElements@@2PAVnsICSSPseudoElement@@A"] pub static nsCSSPseudoElements_after: *mut nsICSSPseudoElement; #[link_name = "\x01?before@nsCSSPseudoElements@@2PAVnsICSSPseudoElement@@A"] diff --git a/servo/components/style/gecko/generated/bindings.rs b/servo/components/style/gecko/generated/bindings.rs index ddac6831eeee..80a7989c9578 100644 --- a/servo/components/style/gecko/generated/bindings.rs +++ b/servo/components/style/gecko/generated/bindings.rs @@ -80,7 +80,7 @@ use gecko_bindings::structs::nsCSSValueSharedList; use gecko_bindings::structs::nsChangeHint; use gecko_bindings::structs::nsCursorImage; use gecko_bindings::structs::nsFont; -use gecko_bindings::structs::nsIAtom; +use gecko_bindings::structs::nsAtom; use gecko_bindings::structs::nsIURI; use gecko_bindings::structs::nsCompatibility; use gecko_bindings::structs::nsRestyleHint; @@ -556,7 +556,7 @@ extern "C" { RawGeckoPresContextBorrowed, values: ServoComputedDataBorrowed, pseudo_type: CSSPseudoElementType, - pseudo_tag: *mut nsIAtom); + pseudo_tag: *mut nsAtom); } extern "C" { pub fn Gecko_ServoStyleContext_Destroy(context: *mut ServoStyleContext); @@ -600,17 +600,17 @@ extern "C" { element: RawGeckoElementBorrowed) -> bool; } extern "C" { - pub fn Gecko_Namespace(element: RawGeckoElementBorrowed) -> *mut nsIAtom; + pub fn Gecko_Namespace(element: RawGeckoElementBorrowed) -> *mut nsAtom; } extern "C" { pub fn Gecko_MatchLang(element: RawGeckoElementBorrowed, - override_lang: *mut nsIAtom, + override_lang: *mut nsAtom, has_override_lang: bool, value: *const u16) -> bool; } extern "C" { pub fn Gecko_GetXMLLangValue(element: RawGeckoElementBorrowed) - -> *mut nsIAtom; + -> *mut nsAtom; } extern "C" { pub fn Gecko_GetDocumentLWTheme(aDocument: *const nsIDocument) @@ -618,108 +618,108 @@ extern "C" { } extern "C" { pub fn Gecko_AtomAttrValue(element: RawGeckoElementBorrowed, - attribute: *mut nsIAtom) -> *mut nsIAtom; + attribute: *mut nsAtom) -> *mut nsAtom; } extern "C" { - pub fn Gecko_LangValue(element: RawGeckoElementBorrowed) -> *mut nsIAtom; + pub fn Gecko_LangValue(element: RawGeckoElementBorrowed) -> *mut nsAtom; } extern "C" { - pub fn Gecko_HasAttr(element: RawGeckoElementBorrowed, ns: *mut nsIAtom, - name: *mut nsIAtom) -> bool; + pub fn Gecko_HasAttr(element: RawGeckoElementBorrowed, ns: *mut nsAtom, + name: *mut nsAtom) -> bool; } extern "C" { pub fn Gecko_AttrEquals(element: RawGeckoElementBorrowed, - ns: *mut nsIAtom, name: *mut nsIAtom, - str: *mut nsIAtom, ignoreCase: bool) -> bool; + ns: *mut nsAtom, name: *mut nsAtom, + str: *mut nsAtom, ignoreCase: bool) -> bool; } extern "C" { pub fn Gecko_AttrDashEquals(element: RawGeckoElementBorrowed, - ns: *mut nsIAtom, name: *mut nsIAtom, - str: *mut nsIAtom, ignore_case: bool) -> bool; + ns: *mut nsAtom, name: *mut nsAtom, + str: *mut nsAtom, ignore_case: bool) -> bool; } extern "C" { pub fn Gecko_AttrIncludes(element: RawGeckoElementBorrowed, - ns: *mut nsIAtom, name: *mut nsIAtom, - str: *mut nsIAtom, ignore_case: bool) -> bool; + ns: *mut nsAtom, name: *mut nsAtom, + str: *mut nsAtom, ignore_case: bool) -> bool; } extern "C" { pub fn Gecko_AttrHasSubstring(element: RawGeckoElementBorrowed, - ns: *mut nsIAtom, name: *mut nsIAtom, - str: *mut nsIAtom, ignore_case: bool) + ns: *mut nsAtom, name: *mut nsAtom, + str: *mut nsAtom, ignore_case: bool) -> bool; } extern "C" { pub fn Gecko_AttrHasPrefix(element: RawGeckoElementBorrowed, - ns: *mut nsIAtom, name: *mut nsIAtom, - str: *mut nsIAtom, ignore_case: bool) -> bool; + ns: *mut nsAtom, name: *mut nsAtom, + str: *mut nsAtom, ignore_case: bool) -> bool; } extern "C" { pub fn Gecko_AttrHasSuffix(element: RawGeckoElementBorrowed, - ns: *mut nsIAtom, name: *mut nsIAtom, - str: *mut nsIAtom, ignore_case: bool) -> bool; + ns: *mut nsAtom, name: *mut nsAtom, + str: *mut nsAtom, ignore_case: bool) -> bool; } extern "C" { pub fn Gecko_ClassOrClassList(element: RawGeckoElementBorrowed, - class_: *mut *mut nsIAtom, - classList: *mut *mut *mut nsIAtom) -> u32; + class_: *mut *mut nsAtom, + classList: *mut *mut *mut nsAtom) -> u32; } extern "C" { pub fn Gecko_SnapshotAtomAttrValue(element: *const ServoElementSnapshot, - attribute: *mut nsIAtom) - -> *mut nsIAtom; + attribute: *mut nsAtom) + -> *mut nsAtom; } extern "C" { pub fn Gecko_SnapshotLangValue(element: *const ServoElementSnapshot) - -> *mut nsIAtom; + -> *mut nsAtom; } extern "C" { pub fn Gecko_SnapshotHasAttr(element: *const ServoElementSnapshot, - ns: *mut nsIAtom, name: *mut nsIAtom) + ns: *mut nsAtom, name: *mut nsAtom) -> bool; } extern "C" { pub fn Gecko_SnapshotAttrEquals(element: *const ServoElementSnapshot, - ns: *mut nsIAtom, name: *mut nsIAtom, - str: *mut nsIAtom, ignoreCase: bool) + ns: *mut nsAtom, name: *mut nsAtom, + str: *mut nsAtom, ignoreCase: bool) -> bool; } extern "C" { pub fn Gecko_SnapshotAttrDashEquals(element: *const ServoElementSnapshot, - ns: *mut nsIAtom, name: *mut nsIAtom, - str: *mut nsIAtom, ignore_case: bool) + ns: *mut nsAtom, name: *mut nsAtom, + str: *mut nsAtom, ignore_case: bool) -> bool; } extern "C" { pub fn Gecko_SnapshotAttrIncludes(element: *const ServoElementSnapshot, - ns: *mut nsIAtom, name: *mut nsIAtom, - str: *mut nsIAtom, ignore_case: bool) + ns: *mut nsAtom, name: *mut nsAtom, + str: *mut nsAtom, ignore_case: bool) -> bool; } extern "C" { pub fn Gecko_SnapshotAttrHasSubstring(element: *const ServoElementSnapshot, - ns: *mut nsIAtom, - name: *mut nsIAtom, - str: *mut nsIAtom, + ns: *mut nsAtom, + name: *mut nsAtom, + str: *mut nsAtom, ignore_case: bool) -> bool; } extern "C" { pub fn Gecko_SnapshotAttrHasPrefix(element: *const ServoElementSnapshot, - ns: *mut nsIAtom, name: *mut nsIAtom, - str: *mut nsIAtom, ignore_case: bool) + ns: *mut nsAtom, name: *mut nsAtom, + str: *mut nsAtom, ignore_case: bool) -> bool; } extern "C" { pub fn Gecko_SnapshotAttrHasSuffix(element: *const ServoElementSnapshot, - ns: *mut nsIAtom, name: *mut nsIAtom, - str: *mut nsIAtom, ignore_case: bool) + ns: *mut nsAtom, name: *mut nsAtom, + str: *mut nsAtom, ignore_case: bool) -> bool; } extern "C" { pub fn Gecko_SnapshotClassOrClassList(element: *const ServoElementSnapshot, - class_: *mut *mut nsIAtom, - classList: *mut *mut *mut nsIAtom) + class_: *mut *mut nsAtom, + classList: *mut *mut *mut nsAtom) -> u32; } extern "C" { @@ -841,32 +841,32 @@ extern "C" { extern "C" { pub fn Gecko_StyleTransition_SetUnsupportedProperty(aTransition: *mut StyleTransition, - aAtom: *mut nsIAtom); + aAtom: *mut nsAtom); } extern "C" { pub fn Gecko_Atomize(aString: *const ::std::os::raw::c_char, aLength: u32) - -> *mut nsIAtom; + -> *mut nsAtom; } extern "C" { - pub fn Gecko_Atomize16(aString: *const nsAString) -> *mut nsIAtom; + pub fn Gecko_Atomize16(aString: *const nsAString) -> *mut nsAtom; } extern "C" { - pub fn Gecko_AddRefAtom(aAtom: *mut nsIAtom); + pub fn Gecko_AddRefAtom(aAtom: *mut nsAtom); } extern "C" { - pub fn Gecko_ReleaseAtom(aAtom: *mut nsIAtom); + pub fn Gecko_ReleaseAtom(aAtom: *mut nsAtom); } extern "C" { - pub fn Gecko_GetAtomAsUTF16(aAtom: *mut nsIAtom, aLength: *mut u32) + pub fn Gecko_GetAtomAsUTF16(aAtom: *mut nsAtom, aLength: *mut u32) -> *const u16; } extern "C" { - pub fn Gecko_AtomEqualsUTF8(aAtom: *mut nsIAtom, + pub fn Gecko_AtomEqualsUTF8(aAtom: *mut nsAtom, aString: *const ::std::os::raw::c_char, aLength: u32) -> bool; } extern "C" { - pub fn Gecko_AtomEqualsUTF8IgnoreCase(aAtom: *mut nsIAtom, + pub fn Gecko_AtomEqualsUTF8IgnoreCase(aAtom: *mut nsAtom, aString: *const ::std::os::raw::c_char, aLength: u32) -> bool; @@ -880,7 +880,7 @@ extern "C" { extern "C" { pub fn Gecko_nsTArray_FontFamilyName_AppendNamed(aNames: *mut nsTArray, - aName: *mut nsIAtom, + aName: *mut nsAtom, aQuoted: bool); } extern "C" { @@ -924,9 +924,9 @@ extern "C" { extern "C" { pub fn Gecko_AppendFeatureValueHashEntry(value_set: *mut gfxFontFeatureValueSet, - family: *mut nsIAtom, + family: *mut nsAtom, alternate: u32, - name: *mut nsIAtom) + name: *mut nsAtom) -> *mut nsTArray<::std::os::raw::c_uint>; } extern "C" { @@ -942,7 +942,7 @@ extern "C" { } extern "C" { pub fn Gecko_AppendAlternateValues(font: *mut nsFont, alternate_name: u32, - atom: *mut nsIAtom); + atom: *mut nsAtom); } extern "C" { pub fn Gecko_CopyAlternateValuesFrom(dest: *mut nsFont, @@ -962,7 +962,7 @@ extern "C" { } extern "C" { pub fn Gecko_SetCounterStyleToName(ptr: *mut CounterStylePtr, - name: *mut nsIAtom, + name: *mut nsAtom, pres_context: RawGeckoPresContextBorrowed); } @@ -982,7 +982,7 @@ extern "C" { } extern "C" { pub fn Gecko_CounterStyle_GetName(ptr: *const CounterStylePtr) - -> *mut nsIAtom; + -> *mut nsAtom; } extern "C" { pub fn Gecko_CounterStyle_GetAnonymous(ptr: *const CounterStylePtr) @@ -1016,7 +1016,7 @@ extern "C" { } extern "C" { pub fn Gecko_SetImageElement(image: *mut nsStyleImage, - atom: *mut nsIAtom); + atom: *mut nsAtom); } extern "C" { pub fn Gecko_CopyImageValueFrom(image: *mut nsStyleImage, @@ -1035,7 +1035,7 @@ extern "C" { -> *const URLValueData; } extern "C" { - pub fn Gecko_GetImageElement(image: *const nsStyleImage) -> *mut nsIAtom; + pub fn Gecko_GetImageElement(image: *const nsStyleImage) -> *mut nsAtom; } extern "C" { pub fn Gecko_GetGradientImageValue(image: *const nsStyleImage) @@ -1189,7 +1189,7 @@ extern "C" { } extern "C" { pub fn Gecko_AppendWillChange(display: *mut nsStyleDisplay, - atom: *mut nsIAtom); + atom: *mut nsAtom); } extern "C" { pub fn Gecko_CopyWillChangeFrom(dest: *mut nsStyleDisplay, @@ -1397,12 +1397,12 @@ extern "C" { } extern "C" { pub fn Gecko_CSSValue_SetStringFromAtom(css_value: nsCSSValueBorrowedMut, - atom: *mut nsIAtom, + atom: *mut nsAtom, unit: nsCSSUnit); } extern "C" { pub fn Gecko_CSSValue_SetAtomIdent(css_value: nsCSSValueBorrowedMut, - atom: *mut nsIAtom); + atom: *mut nsAtom); } extern "C" { pub fn Gecko_CSSValue_SetArray(css_value: nsCSSValueBorrowedMut, @@ -1445,7 +1445,7 @@ extern "C" { } extern "C" { pub fn Gecko_nsStyleFont_SetLang(font: *mut nsStyleFont, - atom: *mut nsIAtom); + atom: *mut nsAtom); } extern "C" { pub fn Gecko_nsStyleFont_CopyLangFrom(aFont: *mut nsStyleFont, @@ -1468,7 +1468,7 @@ extern "C" { RawGeckoPresContextBorrowed); } extern "C" { - pub fn Gecko_GetBaseSize(lang: *mut nsIAtom) -> FontSizePrefs; + pub fn Gecko_GetBaseSize(lang: *mut nsAtom) -> FontSizePrefs; } extern "C" { pub fn Gecko_GetBindingParent(aElement: RawGeckoElementBorrowed) @@ -1537,7 +1537,7 @@ extern "C" { pub fn Gecko_CSSFontFaceRule_Release(aPtr: *mut nsCSSFontFaceRule); } extern "C" { - pub fn Gecko_CSSCounterStyle_Create(name: *mut nsIAtom) + pub fn Gecko_CSSCounterStyle_Create(name: *mut nsAtom) -> *mut nsCSSCounterStyleRule; } extern "C" { @@ -1575,7 +1575,7 @@ extern "C" { arg2: nsCSSPropertyID); } extern "C" { - pub fn Gecko_RegisterNamespace(ns: *mut nsIAtom) -> i32; + pub fn Gecko_RegisterNamespace(ns: *mut nsAtom) -> i32; } extern "C" { pub fn Gecko_ShouldCreateStyleThreadPool() -> bool; @@ -2073,7 +2073,7 @@ extern "C" { } extern "C" { pub fn Servo_StyleSet_GetCounterStyleRule(set: RawServoStyleSetBorrowed, - name: *mut nsIAtom) + name: *mut nsAtom) -> *mut nsCSSCounterStyleRule; } extern "C" { @@ -2116,7 +2116,7 @@ extern "C" { element: RawGeckoElementBorrowed, local_name: - *mut nsIAtom) + *mut nsAtom) -> bool; } extern "C" { @@ -2367,11 +2367,11 @@ extern "C" { } extern "C" { pub fn Servo_KeyframesRule_GetName(rule: RawServoKeyframesRuleBorrowed) - -> *mut nsIAtom; + -> *mut nsAtom; } extern "C" { pub fn Servo_KeyframesRule_SetName(rule: RawServoKeyframesRuleBorrowed, - name: *mut nsIAtom); + name: *mut nsAtom); } extern "C" { pub fn Servo_KeyframesRule_GetCount(rule: RawServoKeyframesRuleBorrowed) @@ -2404,11 +2404,11 @@ extern "C" { } extern "C" { pub fn Servo_NamespaceRule_GetPrefix(rule: RawServoNamespaceRuleBorrowed) - -> *mut nsIAtom; + -> *mut nsAtom; } extern "C" { pub fn Servo_NamespaceRule_GetURI(rule: RawServoNamespaceRuleBorrowed) - -> *mut nsIAtom; + -> *mut nsAtom; } extern "C" { pub fn Servo_PageRule_GetStyle(rule: RawServoPageRuleBorrowed) @@ -2728,7 +2728,7 @@ extern "C" { RawServoDeclarationBlockBorrowed, property: nsCSSPropertyID, - value: *mut nsIAtom); + value: *mut nsAtom); } extern "C" { pub fn Servo_DeclarationBlock_SetKeywordValue(declarations: @@ -2844,14 +2844,14 @@ extern "C" { extern "C" { pub fn Servo_ComputedValues_GetForAnonymousBox(parent_style_or_null: ServoStyleContextBorrowedOrNull, - pseudo_tag: *mut nsIAtom, + pseudo_tag: *mut nsAtom, set: RawServoStyleSetBorrowed) -> ServoStyleContextStrong; } extern "C" { pub fn Servo_ComputedValues_Inherit(set: RawServoStyleSetBorrowed, - pseudo_tag: *mut nsIAtom, + pseudo_tag: *mut nsAtom, parent_style: ServoStyleContextBorrowedOrNull, target: InheritTarget) diff --git a/servo/components/style/gecko/generated/pseudo_element_definition.rs b/servo/components/style/gecko/generated/pseudo_element_definition.rs index de7c3a0b2e8d..3717059ad192 100644 --- a/servo/components/style/gecko/generated/pseudo_element_definition.rs +++ b/servo/components/style/gecko/generated/pseudo_element_definition.rs @@ -867,7 +867,7 @@ None } /// Get a PseudoInfo for a pseudo - pub fn pseudo_info(&self) -> (*mut structs::nsIAtom, CSSPseudoElementType) { + pub fn pseudo_info(&self) -> (*mut structs::nsAtom, CSSPseudoElementType) { (self.atom().as_ptr(), self.pseudo_type()) } diff --git a/servo/components/style/gecko/generated/structs.rs b/servo/components/style/gecko/generated/structs.rs index 307a5af3208d..48e7d132636b 100644 --- a/servo/components/style/gecko/generated/structs.rs +++ b/servo/components/style/gecko/generated/structs.rs @@ -2411,7 +2411,7 @@ pub mod root { #[repr(C)] #[derive(Debug, Copy)] pub struct Element_MappedAttributeEntry { - pub attribute: *mut *mut root::nsIAtom, + pub attribute: *mut *mut root::nsAtom, } #[test] fn bindgen_test_layout_Element_MappedAttributeEntry() { @@ -2537,12 +2537,12 @@ pub mod root { #[repr(C)] #[derive(Debug, Copy)] pub struct NodeInfo_NodeInfoInner { - pub mName: *const root::nsIAtom, - pub mPrefix: *mut root::nsIAtom, + pub mName: *const root::nsAtom, + pub mPrefix: *mut root::nsAtom, pub mNamespaceID: i32, pub mNodeType: u16, pub mNameString: *const root::nsAString, - pub mExtraName: *mut root::nsIAtom, + pub mExtraName: *mut root::nsAtom, pub mHash: root::PLHashNumber, pub mHashInitialized: bool, } @@ -6811,7 +6811,7 @@ pub mod root { #[repr(C)] #[derive(Debug)] pub struct LangGroupFontPrefs { - pub mLangGroup: root::RefPtr, + pub mLangGroup: root::RefPtr, pub mMinimumFontSize: root::nscoord, pub mDefaultVariableFont: root::nsFont, pub mDefaultFixedFont: root::nsFont, @@ -7337,7 +7337,7 @@ pub mod root { pub mDuration: f32, pub mDelay: f32, pub mProperty: root::nsCSSPropertyID, - pub mUnknownProperty: root::RefPtr, + pub mUnknownProperty: root::RefPtr, } #[test] fn bindgen_test_layout_StyleTransition() { @@ -12399,7 +12399,7 @@ pub mod root { pub mScriptUnconstrainedSize: root::nscoord, pub mScriptMinSize: root::nscoord, pub mScriptSizeMultiplier: f32, - pub mLanguage: root::RefPtr, + pub mLanguage: root::RefPtr, } pub const nsStyleFont_kHasFinishStyle: bool = false; #[test] @@ -13038,7 +13038,7 @@ pub mod root { pub mMarkerMid: root::RefPtr, pub mMarkerStart: root::RefPtr, pub mStrokeDasharray: root::nsTArray, - pub mContextProps: root::nsTArray>, + pub mContextProps: root::nsTArray>, pub mStrokeDashoffset: root::nsStyleCoord, pub mStrokeWidth: root::nsStyleCoord, pub mFillOpacity: f32, @@ -13569,7 +13569,7 @@ pub mod root { pub mIsolation: u8, pub mTopLayer: u8, pub mWillChangeBitField: u8, - pub mWillChange: root::nsTArray>, + pub mWillChange: root::nsTArray>, pub mTouchAction: u8, pub mScrollBehavior: u8, pub mScrollSnapTypeX: u8, @@ -14793,7 +14793,7 @@ pub mod root { } #[repr(C)] #[derive(Debug)] - pub struct nsIAtom { + pub struct nsAtom { pub mRefCnt: root::mozilla::ThreadSafeAutoRefCnt, pub _bitfield_1: u32, pub mHash: u32, @@ -14801,35 +14801,35 @@ pub mod root { } #[repr(u8)] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] - pub enum nsIAtom_AtomKind { + pub enum nsAtom_AtomKind { DynamicAtom = 0, StaticAtom = 1, HTML5Atom = 2, } - pub type nsIAtom_HasThreadSafeRefCnt = root::mozilla::TrueType; + pub type nsAtom_HasThreadSafeRefCnt = root::mozilla::TrueType; #[test] - fn bindgen_test_layout_nsIAtom() { - assert_eq!(::std::mem::size_of::() , 24usize , concat ! ( - "Size of: " , stringify ! ( nsIAtom ) )); - assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( - "Alignment of " , stringify ! ( nsIAtom ) )); + fn bindgen_test_layout_nsAtom() { + assert_eq!(::std::mem::size_of::() , 24usize , concat ! ( + "Size of: " , stringify ! ( nsAtom ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( nsAtom ) )); assert_eq! (unsafe { - & ( * ( 0 as * const nsIAtom ) ) . mRefCnt as * const _ as + & ( * ( 0 as * const nsAtom ) ) . mRefCnt as * const _ as usize } , 0usize , concat ! ( - "Alignment of field: " , stringify ! ( nsIAtom ) , "::" , + "Alignment of field: " , stringify ! ( nsAtom ) , "::" , stringify ! ( mRefCnt ) )); assert_eq! (unsafe { - & ( * ( 0 as * const nsIAtom ) ) . mHash as * const _ as + & ( * ( 0 as * const nsAtom ) ) . mHash as * const _ as usize } , 12usize , concat ! ( - "Alignment of field: " , stringify ! ( nsIAtom ) , "::" , + "Alignment of field: " , stringify ! ( nsAtom ) , "::" , stringify ! ( mHash ) )); assert_eq! (unsafe { - & ( * ( 0 as * const nsIAtom ) ) . mString as * const _ as + & ( * ( 0 as * const nsAtom ) ) . mString as * const _ as usize } , 16usize , concat ! ( - "Alignment of field: " , stringify ! ( nsIAtom ) , "::" , + "Alignment of field: " , stringify ! ( nsAtom ) , "::" , stringify ! ( mString ) )); } - impl nsIAtom { + impl nsAtom { #[inline] pub fn mLength(&self) -> u32 { let mut unit_field_val: u32 = @@ -19270,7 +19270,7 @@ pub mod root { pub struct nsCSSCounterStyleRule { pub _base: root::mozilla::css::Rule, pub _base_1: root::nsIDOMCSSCounterStyleRule, - pub mName: root::RefPtr, + pub mName: root::RefPtr, pub mValues: [root::nsCSSValue; 10usize], pub mGeneration: u32, } @@ -19375,7 +19375,7 @@ pub mod root { /// @param aCaseSensitive Whether to do a case-sensitive compare on the values. /// @return ATTR_MISSING, ATTR_VALUE_NO_MATCH or the non-negative index /// indicating the first value of aValues that matched - pub type nsIContent_AttrValuesArray = *const *const root::nsIAtom; + pub type nsIContent_AttrValuesArray = *const *const root::nsAtom; #[repr(u32)] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub enum nsIContent_FlattenedParentType { @@ -19425,7 +19425,7 @@ pub mod root { #[repr(C)] #[derive(Debug)] pub struct nsStyleContext { - pub mPseudoTag: root::RefPtr, + pub mPseudoTag: root::RefPtr, pub mBits: u64, } pub const nsStyleContext_kAllResolvedStructs: @@ -19470,11 +19470,11 @@ pub mod root { pub mAnimationManager: root::RefPtr, pub mRestyleManager: root::RefPtr, pub mCounterStyleManager: root::RefPtr, - pub mMedium: *mut root::nsIAtom, - pub mMediaEmulated: root::RefPtr, + pub mMedium: *mut root::nsAtom, + pub mMediaEmulated: root::RefPtr, pub mFontFeatureValuesLookup: root::RefPtr, pub mLinkHandler: *mut root::nsILinkHandler, - pub mLanguage: root::RefPtr, + pub mLanguage: root::RefPtr, pub mInflationDisabledForShrinkWrap: bool, pub mContainer: u64, pub mBaseMinFontSize: i32, @@ -22484,7 +22484,7 @@ pub mod root { pub mBits: usize, } pub type nsAttrValue_AtomArray = - root::nsTArray>; + root::nsTArray>; pub const nsAttrValue_ValueType_eSVGTypesBegin: root::nsAttrValue_ValueType = nsAttrValue_ValueType::eSVGAngle; @@ -24918,7 +24918,7 @@ pub mod root { #[derive(Debug)] pub struct nsLanguageAtomService { pub mLangToGroup: [u64; 4usize], - pub mLocaleLanguage: root::RefPtr, + pub mLocaleLanguage: root::RefPtr, } pub type nsLanguageAtomService_Encoding = root::mozilla::Encoding; pub type nsLanguageAtomService_NotNull = root::mozilla::NotNull; @@ -25985,7 +25985,7 @@ pub mod root { pub mFloat: root::__BindgenUnionField, pub mString: root::__BindgenUnionField<*mut root::nsStringBuffer>, pub mColor: root::__BindgenUnionField, - pub mAtom: root::__BindgenUnionField<*mut root::nsIAtom>, + pub mAtom: root::__BindgenUnionField<*mut root::nsAtom>, pub mArray: root::__BindgenUnionField<*mut root::nsCSSValue_Array>, pub mURL: root::__BindgenUnionField<*mut root::mozilla::css::URLValue>, pub mImage: root::__BindgenUnionField<*mut root::mozilla::css::ImageValue>, @@ -29795,7 +29795,7 @@ pub mod root { pub mImage: root::__BindgenUnionField<*mut root::nsStyleImageRequest>, pub mGradient: root::__BindgenUnionField<*mut root::nsStyleGradient>, pub mURLValue: root::__BindgenUnionField<*mut root::nsStyleImage_URLValue>, - pub mElementId: root::__BindgenUnionField<*mut root::nsIAtom>, + pub mElementId: root::__BindgenUnionField<*mut root::nsAtom>, pub bindgen_union_field: u64, } #[test] @@ -31907,7 +31907,7 @@ pub mod root { #[repr(C)] #[derive(Debug, Copy)] pub struct nsMediaFeature { - pub mName: *mut *mut root::nsIAtom, + pub mName: *mut *mut root::nsAtom, pub mRangeType: root::nsMediaFeature_RangeType, pub mValueType: root::nsMediaFeature_ValueType, pub mReqFlags: u8, @@ -31945,7 +31945,7 @@ pub mod root { pub struct nsMediaFeature__bindgen_ty_1 { pub mInitializer_: root::__BindgenUnionField<*const ::std::os::raw::c_void>, pub mKeywordTable: root::__BindgenUnionField<*const root::nsCSSProps_KTableEntry>, - pub mMetric: root::__BindgenUnionField<*const *const root::nsIAtom>, + pub mMetric: root::__BindgenUnionField<*const *const root::nsAtom>, pub bindgen_union_field: u64, } #[test] @@ -32339,7 +32339,7 @@ pub mod root { pub mHasOnly: bool, pub mTypeOmitted: bool, pub mHadUnknownExpression: bool, - pub mMediaType: root::RefPtr, + pub mMediaType: root::RefPtr, pub mExpressions: root::nsTArray, } #[test] @@ -32691,15 +32691,15 @@ pub mod root { root::nsTArray<*mut root::nsCSSSelector> ) )); } #[test] - fn __bindgen_test_layout_RefPtr_open0_nsIAtom_close0_instantiation() { - assert_eq!(::std::mem::size_of::>() , + fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() , + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); + root::RefPtr ) )); } #[test] fn __bindgen_test_layout_RefPtr_open0_nsStyleImageRequest_close0_instantiation() { @@ -32790,26 +32790,26 @@ pub mod root { root::nsTArray ) )); } #[test] - fn __bindgen_test_layout_nsTArray_open0_RefPtr_open1_nsIAtom_close1_close0_instantiation() { - assert_eq!(::std::mem::size_of::>>() + fn __bindgen_test_layout_nsTArray_open0_RefPtr_open1_nsAtom_close1_close0_instantiation() { + assert_eq!(::std::mem::size_of::>>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::nsTArray> ) )); - assert_eq!(::std::mem::align_of::>>() + root::nsTArray> ) )); + assert_eq!(::std::mem::align_of::>>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::nsTArray> ) )); + root::nsTArray> ) )); } #[test] - fn __bindgen_test_layout_RefPtr_open0_nsIAtom_close0_instantiation_1() { - assert_eq!(::std::mem::size_of::>() , + fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_1() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() , + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); + root::RefPtr ) )); } #[test] fn __bindgen_test_layout_UniquePtr_open0_nsStyleGridTemplate_DefaultDelete_open1_nsStyleGridTemplate_close1_close0_instantiation() { @@ -32869,26 +32869,26 @@ pub mod root { )); } #[test] - fn __bindgen_test_layout_nsTArray_open0_RefPtr_open1_nsIAtom_close1_close0_instantiation_1() { - assert_eq!(::std::mem::size_of::>>() + fn __bindgen_test_layout_nsTArray_open0_RefPtr_open1_nsAtom_close1_close0_instantiation_1() { + assert_eq!(::std::mem::size_of::>>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::nsTArray> ) )); - assert_eq!(::std::mem::align_of::>>() + root::nsTArray> ) )); + assert_eq!(::std::mem::align_of::>>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::nsTArray> ) )); + root::nsTArray> ) )); } #[test] - fn __bindgen_test_layout_RefPtr_open0_nsIAtom_close0_instantiation_2() { - assert_eq!(::std::mem::size_of::>() , + fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_2() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() , + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); + root::RefPtr ) )); } #[test] fn __bindgen_test_layout_nsTArray_open0_Position_close0_instantiation() { @@ -34504,15 +34504,15 @@ pub mod root { u64 ) )); } #[test] - fn __bindgen_test_layout_RefPtr_open0_nsIAtom_close0_instantiation_3() { - assert_eq!(::std::mem::size_of::>() , + fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_3() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() , + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); + root::RefPtr ) )); } #[test] fn __bindgen_test_layout_RefPtr_open0_nsCSSFontFaceRule_close0_instantiation() { @@ -34548,15 +34548,15 @@ pub mod root { root::nsTArray<*mut root::nsIContent> ) )); } #[test] - fn __bindgen_test_layout_RefPtr_open0_nsIAtom_close0_instantiation_4() { - assert_eq!(::std::mem::size_of::>() , + fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_4() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() , + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); + root::RefPtr ) )); } #[test] fn __bindgen_test_layout_nsCOMPtr_open0_nsIStyleRule_close0_instantiation() { @@ -34761,15 +34761,15 @@ pub mod root { root::RefPtr ) )); } #[test] - fn __bindgen_test_layout_RefPtr_open0_nsIAtom_close0_instantiation_5() { - assert_eq!(::std::mem::size_of::>() , + fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_5() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() , + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); + root::RefPtr ) )); } #[test] fn __bindgen_test_layout_RefPtr_open0_gfxFontFeatureValueSet_close0_instantiation_1() { @@ -34783,15 +34783,15 @@ pub mod root { root::RefPtr ) )); } #[test] - fn __bindgen_test_layout_RefPtr_open0_nsIAtom_close0_instantiation_6() { - assert_eq!(::std::mem::size_of::>() , + fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_6() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() , + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); + root::RefPtr ) )); } #[test] fn __bindgen_test_layout_nsCOMPtr_open0_nsITheme_close0_instantiation() { @@ -34882,37 +34882,37 @@ pub mod root { root::nsAutoPtr ) )); } #[test] - fn __bindgen_test_layout_nsRefPtrHashKey_open0_nsIAtom_close0_instantiation() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_nsRefPtrHashKey_open0_nsAtom_close0_instantiation() { + assert_eq!(::std::mem::size_of::>() , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::nsRefPtrHashKey ) )); - assert_eq!(::std::mem::align_of::>() + root::nsRefPtrHashKey ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::nsRefPtrHashKey ) )); + root::nsRefPtrHashKey ) )); } #[test] - fn __bindgen_test_layout_nsTArray_open0_RefPtr_open1_nsIAtom_close1_close0_instantiation_2() { - assert_eq!(::std::mem::size_of::>>() + fn __bindgen_test_layout_nsTArray_open0_RefPtr_open1_nsAtom_close1_close0_instantiation_2() { + assert_eq!(::std::mem::size_of::>>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::nsTArray> ) )); - assert_eq!(::std::mem::align_of::>>() + root::nsTArray> ) )); + assert_eq!(::std::mem::align_of::>>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::nsTArray> ) )); + root::nsTArray> ) )); } #[test] - fn __bindgen_test_layout_RefPtr_open0_nsIAtom_close0_instantiation_7() { - assert_eq!(::std::mem::size_of::>() , + fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_7() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() , + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); + root::RefPtr ) )); } #[test] fn __bindgen_test_layout_nsCOMPtr_open0_nsIPrincipal_close0_instantiation_4() { @@ -35251,26 +35251,26 @@ pub mod root { root::mozilla::StaticRefPtr ) )); } #[test] - fn __bindgen_test_layout_nsRefPtrHashKey_open0_nsIAtom_close0_instantiation_1() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_nsRefPtrHashKey_open0_nsAtom_close0_instantiation_1() { + assert_eq!(::std::mem::size_of::>() , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::nsRefPtrHashKey ) )); - assert_eq!(::std::mem::align_of::>() + root::nsRefPtrHashKey ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::nsRefPtrHashKey ) )); + root::nsRefPtrHashKey ) )); } #[test] - fn __bindgen_test_layout_RefPtr_open0_nsIAtom_close0_instantiation_8() { - assert_eq!(::std::mem::size_of::>() , + fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_8() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() , + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); + root::RefPtr ) )); } #[test] fn __bindgen_test_layout_UniquePtr_open0_TimeoutManager_DefaultDelete_open1_TimeoutManager_close1_close0_instantiation() { @@ -35751,15 +35751,15 @@ pub mod root { root::nsTArray<::nsstring::nsStringRepr> ) )); } #[test] - fn __bindgen_test_layout_RefPtr_open0_nsIAtom_close0_instantiation_9() { - assert_eq!(::std::mem::size_of::>() , + fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_9() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() , + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); + root::RefPtr ) )); } #[test] fn __bindgen_test_layout_nsAutoPtr_open0_LangGroupFontPrefs_close0_instantiation() { @@ -35786,15 +35786,15 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_nsRefPtrHashKey_open0_nsIAtom_close0_instantiation_2() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_nsRefPtrHashKey_open0_nsAtom_close0_instantiation_2() { + assert_eq!(::std::mem::size_of::>() , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::nsRefPtrHashKey ) )); - assert_eq!(::std::mem::align_of::>() + root::nsRefPtrHashKey ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::nsRefPtrHashKey ) )); + root::nsRefPtrHashKey ) )); } #[test] fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_228468_close0_instantiation() { @@ -36388,15 +36388,15 @@ pub mod root { root::nsTArray<::nsstring::nsStringRepr> ) )); } #[test] - fn __bindgen_test_layout_RefPtr_open0_nsIAtom_close0_instantiation_10() { - assert_eq!(::std::mem::size_of::>() , + fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_10() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() , + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); + root::RefPtr ) )); } #[test] fn __bindgen_test_layout_nsTArray_open0_nsStyleCoord_close0_instantiation_3() { @@ -37301,15 +37301,15 @@ pub mod root { root::nsTArray<*mut root::mozilla::css::DocumentRule> ) )); } #[test] - fn __bindgen_test_layout_RefPtr_open0_nsIAtom_close0_instantiation_11() { - assert_eq!(::std::mem::size_of::>() , + fn __bindgen_test_layout_RefPtr_open0_nsAtom_close0_instantiation_11() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() , + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); + root::RefPtr ) )); } #[test] fn __bindgen_test_layout_nsTArray_open0_nsMediaExpression_close0_instantiation() { diff --git a/servo/components/style/gecko/pseudo_element_definition.mako.rs b/servo/components/style/gecko/pseudo_element_definition.mako.rs index 41ac2500bbeb..eaa178ad06bb 100644 --- a/servo/components/style/gecko/pseudo_element_definition.mako.rs +++ b/servo/components/style/gecko/pseudo_element_definition.mako.rs @@ -143,7 +143,7 @@ impl PseudoElement { } /// Get a PseudoInfo for a pseudo - pub fn pseudo_info(&self) -> (*mut structs::nsIAtom, CSSPseudoElementType) { + pub fn pseudo_info(&self) -> (*mut structs::nsAtom, CSSPseudoElementType) { (self.atom().as_ptr(), self.pseudo_type()) } diff --git a/servo/components/style/gecko/regen_atoms.py b/servo/components/style/gecko/regen_atoms.py index f47f036a592a..7ee1ccab3088 100755 --- a/servo/components/style/gecko/regen_atoms.py +++ b/servo/components/style/gecko/regen_atoms.py @@ -42,14 +42,14 @@ class GkAtomSource: PATTERN = re.compile('^(GK_ATOM)\((.+),\s*"(.*)"\)') FILE = "include/nsGkAtomList.h" CLASS = "nsGkAtoms" - TYPE = "nsIAtom" + TYPE = "nsAtom" class CSSPseudoElementsAtomSource: PATTERN = re.compile('^(CSS_PSEUDO_ELEMENT)\((.+),\s*"(.*)",') FILE = "include/nsCSSPseudoElementList.h" CLASS = "nsCSSPseudoElements" - # NB: nsICSSPseudoElement is effectively the same as a nsIAtom, but we need + # NB: nsICSSPseudoElement is effectively the same as a nsAtom, but we need # this for MSVC name mangling. TYPE = "nsICSSPseudoElement" @@ -163,14 +163,14 @@ class FileAvoidWrite(BytesIO): self.close() -IMPORTS = ("\nuse gecko_bindings::structs::nsIAtom;" +IMPORTS = ("\nuse gecko_bindings::structs::nsAtom;" "\nuse string_cache::Atom;\n\n") ATOM_TEMPLATE = (" #[link_name = \"{link_name}\"]\n" " pub static {name}: *mut {type};") UNSAFE_STATIC = ("#[inline(always)]\n" - "pub unsafe fn atom_from_static(ptr: *mut nsIAtom) -> Atom {\n" + "pub unsafe fn atom_from_static(ptr: *mut nsAtom) -> Atom {\n" " Atom::from_static(ptr)\n" "}\n\n") @@ -220,7 +220,7 @@ def write_atom_macro(atoms, file_name): f.write(IMPORTS) for source in SOURCES: - if source.TYPE != "nsIAtom": + if source.TYPE != "nsAtom": f.write("pub enum {} {{}}\n\n".format(source.TYPE)) f.write(UNSAFE_STATIC) diff --git a/servo/components/style/gecko/snapshot_helpers.rs b/servo/components/style/gecko/snapshot_helpers.rs index 70af6f7082ab..79963e69ca14 100644 --- a/servo/components/style/gecko/snapshot_helpers.rs +++ b/servo/components/style/gecko/snapshot_helpers.rs @@ -5,7 +5,7 @@ //! Element an snapshot common logic. use CaseSensitivityExt; -use gecko_bindings::structs::nsIAtom; +use gecko_bindings::structs::nsAtom; use gecko_string_cache::WeakAtom; use selectors::attr::CaseSensitivity; use std::{ptr, slice}; @@ -13,7 +13,7 @@ use string_cache::Atom; /// A function that, given an element of type `T`, allows you to get a single /// class or a class list. -pub type ClassOrClassList = unsafe extern fn (T, *mut *mut nsIAtom, *mut *mut *mut nsIAtom) -> u32; +pub type ClassOrClassList = unsafe extern fn (T, *mut *mut nsAtom, *mut *mut *mut nsAtom) -> u32; /// Given an item `T`, a class name, and a getter function, return whether that /// element has the class that `name` represents. @@ -23,8 +23,8 @@ pub fn has_class(item: T, getter: ClassOrClassList) -> bool { unsafe { - let mut class: *mut nsIAtom = ptr::null_mut(); - let mut list: *mut *mut nsIAtom = ptr::null_mut(); + let mut class: *mut nsAtom = ptr::null_mut(); + let mut list: *mut *mut nsAtom = ptr::null_mut(); let length = getter(item, &mut class, &mut list); match length { 0 => false, @@ -46,8 +46,8 @@ pub fn each_class(item: T, where F: FnMut(&Atom) { unsafe { - let mut class: *mut nsIAtom = ptr::null_mut(); - let mut list: *mut *mut nsIAtom = ptr::null_mut(); + let mut class: *mut nsAtom = ptr::null_mut(); + let mut list: *mut *mut nsAtom = ptr::null_mut(); let length = getter(item, &mut class, &mut list); match length { 0 => {} diff --git a/servo/components/style/gecko/wrapper.rs b/servo/components/style/gecko/wrapper.rs index e148e7f2546e..d15715b46c18 100644 --- a/servo/components/style/gecko/wrapper.rs +++ b/servo/components/style/gecko/wrapper.rs @@ -54,7 +54,7 @@ use gecko_bindings::bindings::Gecko_UnsetDirtyStyleAttr; use gecko_bindings::bindings::Gecko_UpdateAnimations; use gecko_bindings::structs; use gecko_bindings::structs::{RawGeckoElement, RawGeckoNode, RawGeckoXBLBinding}; -use gecko_bindings::structs::{nsIAtom, nsIContent, nsINode_BooleanFlag}; +use gecko_bindings::structs::{nsAtom, nsIContent, nsINode_BooleanFlag}; use gecko_bindings::structs::ELEMENT_HANDLED_SNAPSHOT; use gecko_bindings::structs::ELEMENT_HAS_ANIMATION_ONLY_DIRTY_DESCENDANTS_FOR_SERVO; use gecko_bindings::structs::ELEMENT_HAS_DIRTY_DESCENDANTS_FOR_SERVO; @@ -2065,11 +2065,11 @@ impl<'le> ::selectors::Element for GeckoElement<'le> { /// A few helpers to help with attribute selectors and snapshotting. pub trait NamespaceConstraintHelpers { /// Returns the namespace of the selector, or null otherwise. - fn atom_or_null(&self) -> *mut nsIAtom; + fn atom_or_null(&self) -> *mut nsAtom; } impl<'a> NamespaceConstraintHelpers for NamespaceConstraint<&'a Namespace> { - fn atom_or_null(&self) -> *mut nsIAtom { + fn atom_or_null(&self) -> *mut nsAtom { match *self { NamespaceConstraint::Any => ptr::null_mut(), NamespaceConstraint::Specific(ref ns) => ns.0.as_ptr(), diff --git a/servo/components/style/gecko_string_cache/mod.rs b/servo/components/style/gecko_string_cache/mod.rs index 20121d5f5489..d48b679ceaf6 100644 --- a/servo/components/style/gecko_string_cache/mod.rs +++ b/servo/components/style/gecko_string_cache/mod.rs @@ -4,13 +4,13 @@ #![allow(unsafe_code)] -//! A drop-in replacement for string_cache, but backed by Gecko `nsIAtom`s. +//! A drop-in replacement for string_cache, but backed by Gecko `nsAtom`s. use gecko_bindings::bindings::Gecko_AddRefAtom; use gecko_bindings::bindings::Gecko_Atomize; use gecko_bindings::bindings::Gecko_Atomize16; use gecko_bindings::bindings::Gecko_ReleaseAtom; -use gecko_bindings::structs::{nsIAtom, nsIAtom_AtomKind}; +use gecko_bindings::structs::{nsAtom, nsAtom_AtomKind}; use nsstring::{nsAString, nsStr}; use precomputed_hash::PrecomputedHash; use std::ascii::AsciiExt; @@ -46,9 +46,9 @@ pub struct Atom(*mut WeakAtom); /// /// Only usable as `&'a WeakAtom`, /// where `'a` is the lifetime of something that holds a strong reference to that atom. -pub struct WeakAtom(nsIAtom); +pub struct WeakAtom(nsAtom); -/// A BorrowedAtom for Gecko is just a weak reference to a `nsIAtom`, that +/// A BorrowedAtom for Gecko is just a weak reference to a `nsAtom`, that /// hasn't been bumped. pub type BorrowedAtom<'a> = &'a WeakAtom; @@ -92,9 +92,9 @@ unsafe impl Sync for Atom {} unsafe impl Sync for WeakAtom {} impl WeakAtom { - /// Construct a `WeakAtom` from a raw `nsIAtom`. + /// Construct a `WeakAtom` from a raw `nsAtom`. #[inline] - pub unsafe fn new<'a>(atom: *const nsIAtom) -> &'a mut Self { + pub unsafe fn new<'a>(atom: *const nsAtom) -> &'a mut Self { &mut *(atom as *mut WeakAtom) } @@ -149,7 +149,7 @@ impl WeakAtom { #[inline] pub fn is_static(&self) -> bool { unsafe { - (*self.as_ptr()).mKind() == nsIAtom_AtomKind::StaticAtom as u32 + (*self.as_ptr()).mKind() == nsAtom_AtomKind::StaticAtom as u32 } } @@ -169,9 +169,9 @@ impl WeakAtom { /// Returns the atom as a mutable pointer. #[inline] - pub fn as_ptr(&self) -> *mut nsIAtom { - let const_ptr: *const nsIAtom = &self.0; - const_ptr as *mut nsIAtom + pub fn as_ptr(&self) -> *mut nsAtom { + let const_ptr: *const nsAtom = &self.0; + const_ptr as *mut nsAtom } /// Convert this atom to ASCII lower-case @@ -240,7 +240,7 @@ impl fmt::Display for WeakAtom { impl Atom { /// Execute a callback with the atom represented by `ptr`. - pub unsafe fn with(ptr: *mut nsIAtom, callback: F) -> R where F: FnOnce(&Atom) -> R { + pub unsafe fn with(ptr: *mut nsAtom, callback: F) -> R where F: FnOnce(&Atom) -> R { let atom = Atom(WeakAtom::new(ptr)); let ret = callback(&atom); mem::forget(atom); @@ -254,7 +254,7 @@ impl Atom { /// that way, now we have sugar for is_static, creating atoms using /// Atom::from should involve almost no overhead. #[inline] - unsafe fn from_static(ptr: *mut nsIAtom) -> Self { + unsafe fn from_static(ptr: *mut nsAtom) -> Self { let atom = Atom(ptr as *mut WeakAtom); debug_assert!(atom.is_static(), "Called from_static for a non-static atom!"); @@ -264,16 +264,16 @@ impl Atom { /// Creates an atom from a dynamic atom pointer that has already had AddRef /// called on it. #[inline] - pub unsafe fn from_addrefed(ptr: *mut nsIAtom) -> Self { + pub unsafe fn from_addrefed(ptr: *mut nsAtom) -> Self { assert!(!ptr.is_null()); unsafe { Atom(WeakAtom::new(ptr)) } } - /// Convert this atom into an addrefed nsIAtom pointer. + /// Convert this atom into an addrefed nsAtom pointer. #[inline] - pub fn into_addrefed(self) -> *mut nsIAtom { + pub fn into_addrefed(self) -> *mut nsAtom { let ptr = self.as_ptr(); mem::forget(self); ptr @@ -375,9 +375,9 @@ impl From for Atom { } } -impl From<*mut nsIAtom> for Atom { +impl From<*mut nsAtom> for Atom { #[inline] - fn from(ptr: *mut nsIAtom) -> Atom { + fn from(ptr: *mut nsAtom) -> Atom { assert!(!ptr.is_null()); unsafe { let ret = Atom(WeakAtom::new(ptr)); diff --git a/servo/components/style/gecko_string_cache/namespace.rs b/servo/components/style/gecko_string_cache/namespace.rs index 61a89a86f062..92288574e145 100644 --- a/servo/components/style/gecko_string_cache/namespace.rs +++ b/servo/components/style/gecko_string_cache/namespace.rs @@ -4,7 +4,7 @@ //! A type to represent a namespace. -use gecko_bindings::structs::nsIAtom; +use gecko_bindings::structs::nsAtom; use precomputed_hash::PrecomputedHash; use std::borrow::Borrow; use std::fmt; @@ -76,7 +76,7 @@ impl Borrow for Namespace { impl WeakNamespace { /// Trivially construct a WeakNamespace. #[inline] - pub unsafe fn new<'a>(atom: *mut nsIAtom) -> &'a Self { + pub unsafe fn new<'a>(atom: *mut nsAtom) -> &'a Self { &*(atom as *const WeakNamespace) } diff --git a/servo/components/style/properties/gecko.mako.rs b/servo/components/style/properties/gecko.mako.rs index 9501cf0e839f..c20470a27aa3 100644 --- a/servo/components/style/properties/gecko.mako.rs +++ b/servo/components/style/properties/gecko.mako.rs @@ -175,7 +175,7 @@ impl Clone for ComputedValuesInner { } } -type PseudoInfo = (*mut structs::nsIAtom, structs::CSSPseudoElementType); +type PseudoInfo = (*mut structs::nsAtom, structs::CSSPseudoElementType); type ParentStyleContextInfo<'a> = Option< &'a ComputedValues>; impl ComputedValuesInner { @@ -220,7 +220,7 @@ impl ComputedValuesInner { pres_context: bindings::RawGeckoPresContextBorrowed, parent: ParentStyleContextInfo, pseudo_ty: structs::CSSPseudoElementType, - pseudo_tag: *mut structs::nsIAtom + pseudo_tag: *mut structs::nsAtom ) -> Arc { let arc = unsafe { let arc: Arc = Arc::new(uninitialized()); @@ -3456,7 +3456,7 @@ fn static_assert() { pub fn clone_will_change(&self) -> longhands::will_change::computed_value::T { use properties::longhands::will_change::computed_value::T; - use gecko_bindings::structs::nsIAtom; + use gecko_bindings::structs::nsAtom; use values::CustomIdent; if self.gecko.mWillChange.len() == 0 { @@ -3464,7 +3464,7 @@ fn static_assert() { } else { T::AnimateableFeatures( self.gecko.mWillChange.iter().map(|gecko_atom| { - CustomIdent((gecko_atom.mRawPtr as *mut nsIAtom).into()) + CustomIdent((gecko_atom.mRawPtr as *mut nsAtom).into()) }).collect() ) } diff --git a/servo/ports/geckolib/glue.rs b/servo/ports/geckolib/glue.rs index fc88368603c0..06c7b794a962 100644 --- a/servo/ports/geckolib/glue.rs +++ b/servo/ports/geckolib/glue.rs @@ -80,7 +80,7 @@ use style::gecko_bindings::structs; use style::gecko_bindings::structs::{CSSPseudoElementType, CompositeOperation}; use style::gecko_bindings::structs::{Loader, LoaderReusableStyleSheets}; use style::gecko_bindings::structs::{RawServoStyleRule, ServoStyleContextStrong, RustString}; -use style::gecko_bindings::structs::{ServoStyleSheet, SheetParsingMode, nsIAtom, nsCSSPropertyID}; +use style::gecko_bindings::structs::{ServoStyleSheet, SheetParsingMode, nsAtom, nsCSSPropertyID}; use style::gecko_bindings::structs::{nsCSSFontFaceRule, nsCSSCounterStyleRule}; use style::gecko_bindings::structs::{nsRestyleHint, nsChangeHint, PropertyValuePair}; use style::gecko_bindings::structs::IterationCompositeOperation; @@ -1589,12 +1589,12 @@ pub extern "C" fn Servo_Keyframe_SetStyle(keyframe: RawServoKeyframeBorrowed, } #[no_mangle] -pub extern "C" fn Servo_KeyframesRule_GetName(rule: RawServoKeyframesRuleBorrowed) -> *mut nsIAtom { +pub extern "C" fn Servo_KeyframesRule_GetName(rule: RawServoKeyframesRuleBorrowed) -> *mut nsAtom { read_locked_arc(rule, |rule: &KeyframesRule| rule.name.as_atom().as_ptr()) } #[no_mangle] -pub extern "C" fn Servo_KeyframesRule_SetName(rule: RawServoKeyframesRuleBorrowed, name: *mut nsIAtom) { +pub extern "C" fn Servo_KeyframesRule_SetName(rule: RawServoKeyframesRuleBorrowed, name: *mut nsAtom) { write_locked_arc(rule, |rule: &mut KeyframesRule| { rule.name = KeyframesName::Ident(CustomIdent(unsafe { Atom::from_addrefed(name) })); }) @@ -1665,14 +1665,14 @@ pub extern "C" fn Servo_MediaRule_GetMedia(rule: RawServoMediaRuleBorrowed) -> R } #[no_mangle] -pub extern "C" fn Servo_NamespaceRule_GetPrefix(rule: RawServoNamespaceRuleBorrowed) -> *mut nsIAtom { +pub extern "C" fn Servo_NamespaceRule_GetPrefix(rule: RawServoNamespaceRuleBorrowed) -> *mut nsAtom { read_locked_arc(rule, |rule: &NamespaceRule| { rule.prefix.as_ref().unwrap_or(&atom!("")).as_ptr() }) } #[no_mangle] -pub extern "C" fn Servo_NamespaceRule_GetURI(rule: RawServoNamespaceRuleBorrowed) -> *mut nsIAtom { +pub extern "C" fn Servo_NamespaceRule_GetURI(rule: RawServoNamespaceRuleBorrowed) -> *mut nsAtom { read_locked_arc(rule, |rule: &NamespaceRule| rule.url.0.as_ptr()) } @@ -1726,7 +1726,7 @@ pub extern "C" fn Servo_FontFeatureValuesRule_GetValueText(rule: RawServoFontFea #[no_mangle] pub extern "C" fn Servo_ComputedValues_GetForAnonymousBox(parent_style_or_null: ServoStyleContextBorrowedOrNull, - pseudo_tag: *mut nsIAtom, + pseudo_tag: *mut nsAtom, raw_data: RawServoStyleSetBorrowed) -> ServoStyleContextStrong { let global_style_data = &*GLOBAL_STYLE_DATA; @@ -1981,7 +1981,7 @@ fn get_pseudo_style( #[no_mangle] pub extern "C" fn Servo_ComputedValues_Inherit( raw_data: RawServoStyleSetBorrowed, - pseudo_tag: *mut nsIAtom, + pseudo_tag: *mut nsAtom, parent_style_context: ServoStyleContextBorrowedOrNull, target: structs::InheritTarget ) -> ServoStyleContextStrong { @@ -2662,7 +2662,7 @@ pub extern "C" fn Servo_DeclarationBlock_SetIdentStringValue(declarations: property: nsCSSPropertyID, value: - *mut nsIAtom) { + *mut nsAtom) { use style::properties::{PropertyDeclaration, LonghandId}; use style::properties::longhands::_x_lang::computed_value::T as Lang; @@ -3821,7 +3821,7 @@ pub extern "C" fn Servo_StyleSet_GetFontFaceRules(raw_data: RawServoStyleSetBorr #[no_mangle] pub extern "C" fn Servo_StyleSet_GetCounterStyleRule(raw_data: RawServoStyleSetBorrowed, - name: *mut nsIAtom) -> *mut nsCSSCounterStyleRule { + name: *mut nsAtom) -> *mut nsCSSCounterStyleRule { let data = PerDocumentStyleData::from_ffi(raw_data).borrow(); unsafe { @@ -3925,7 +3925,7 @@ pub extern "C" fn Servo_UACache_AddSizeOf( pub extern "C" fn Servo_StyleSet_MightHaveAttributeDependency( raw_data: RawServoStyleSetBorrowed, element: RawGeckoElementBorrowed, - local_name: *mut nsIAtom, + local_name: *mut nsAtom, ) -> bool { let data = PerDocumentStyleData::from_ffi(raw_data).borrow(); let element = GeckoElement(element); From d225f7151b76304ffaf01c42eba8a54e97cfd3d2 Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Tue, 3 Oct 2017 09:05:19 +1100 Subject: [PATCH 13/15] Bug 1400460 - Rename nsIAtom as nsAtom. r=hiro. (Path is actually r=froydnj.) Bug 1400459 devirtualized nsIAtom so that it is no longer a subclass of nsISupports. This means that nsAtom is now a better name for it than nsIAtom. MozReview-Commit-ID: 91U22X2NydP --HG-- rename : xpcom/ds/nsIAtom.h => xpcom/ds/nsAtom.h extra : rebase_source : ac3e904a21b8b48e74534fff964f1623ee937c67 --- .gdbinit | 2 +- .lldbinit | 2 +- accessible/base/ARIAMap.cpp | 6 +- accessible/base/ARIAMap.h | 8 +- accessible/base/ARIAStateMap.cpp | 8 +- accessible/base/AccEvent.h | 6 +- accessible/base/AccIterator.cpp | 6 +- accessible/base/AccIterator.h | 6 +- accessible/base/Logging.cpp | 4 +- accessible/base/nsAccUtils.cpp | 12 +- accessible/base/nsAccUtils.h | 12 +- accessible/base/nsAccessibilityService.cpp | 2 +- accessible/base/nsAccessibilityService.h | 12 +- accessible/base/nsCoreUtils.cpp | 2 +- accessible/base/nsCoreUtils.h | 2 +- accessible/base/nsTextEquivUtils.cpp | 2 +- accessible/base/nsTextEquivUtils.h | 2 +- accessible/generic/Accessible-inl.h | 2 +- accessible/generic/Accessible.cpp | 10 +- accessible/generic/Accessible.h | 8 +- accessible/generic/DocAccessible.cpp | 20 +- accessible/generic/DocAccessible.h | 16 +- accessible/generic/HyperTextAccessible.cpp | 2 +- accessible/generic/HyperTextAccessible.h | 2 +- accessible/html/HTMLElementAccessibles.cpp | 2 +- accessible/html/HTMLElementAccessibles.h | 2 +- accessible/ipc/ProxyAccessibleShared.h | 4 +- accessible/ipc/other/DocAccessibleChild.cpp | 6 +- accessible/ipc/other/ProxyAccessible.cpp | 4 +- accessible/mac/mozAccessible.mm | 4 +- accessible/windows/msaa/GeckoCustom.cpp | 2 +- accessible/xul/XULSliderAccessible.cpp | 8 +- accessible/xul/XULSliderAccessible.h | 8 +- caps/BasePrincipal.cpp | 2 +- caps/BasePrincipal.h | 8 +- caps/ExpandedPrincipal.cpp | 2 +- caps/ExpandedPrincipal.h | 2 +- docshell/base/nsDocShell.cpp | 2 +- docshell/base/nsDocShellTreeOwner.cpp | 2 +- docshell/shistory/nsSHEntryShared.cpp | 4 +- dom/animation/AnimationUtils.cpp | 4 +- dom/animation/CSSPseudoElement.cpp | 4 +- dom/animation/CSSPseudoElement.h | 2 +- dom/animation/EffectCompositor.cpp | 2 +- dom/animation/EffectCompositor.h | 2 +- dom/animation/EffectSet.cpp | 14 +- dom/animation/EffectSet.h | 6 +- dom/animation/KeyframeEffectReadOnly.cpp | 2 +- dom/asmjscache/AsmJSCache.cpp | 2 +- dom/base/AnonymousContent.cpp | 4 +- dom/base/Attr.cpp | 4 +- dom/base/CustomElementRegistry.cpp | 42 ++-- dom/base/CustomElementRegistry.h | 34 +-- dom/base/DOMImplementation.cpp | 2 +- dom/base/DirectionalityUtils.cpp | 4 +- dom/base/DocumentFragment.h | 10 +- dom/base/DocumentType.cpp | 4 +- dom/base/DocumentType.h | 4 +- dom/base/Element.cpp | 94 ++++---- dom/base/Element.h | 100 ++++---- dom/base/FragmentOrElement.cpp | 40 ++-- dom/base/FragmentOrElement.h | 4 +- dom/base/IDTracker.cpp | 4 +- dom/base/IDTracker.h | 4 +- dom/base/Link.cpp | 2 +- dom/base/Link.h | 2 +- dom/base/NodeInfo.cpp | 6 +- dom/base/NodeInfo.h | 34 +-- dom/base/NodeInfoInlines.h | 8 +- dom/base/ShadowRoot.cpp | 6 +- dom/base/ShadowRoot.h | 6 +- dom/base/WebSocket.cpp | 4 +- dom/base/WebSocket.h | 4 +- dom/base/nsAtomListUtils.cpp | 4 +- dom/base/nsAtomListUtils.h | 4 +- dom/base/nsAttrAndChildArray.cpp | 10 +- dom/base/nsAttrAndChildArray.h | 8 +- dom/base/nsAttrName.h | 20 +- dom/base/nsAttrValue.cpp | 54 ++--- dom/base/nsAttrValue.h | 24 +- dom/base/nsAttrValueInlines.h | 2 +- dom/base/nsCCUncollectableMarker.cpp | 2 +- dom/base/nsContentIterator.cpp | 4 +- dom/base/nsContentList.cpp | 24 +- dom/base/nsContentList.h | 12 +- dom/base/nsContentListDeclarations.h | 4 +- dom/base/nsContentSink.cpp | 6 +- dom/base/nsContentSink.h | 4 +- dom/base/nsContentUtils.cpp | 80 +++---- dom/base/nsContentUtils.h | 52 ++--- dom/base/nsDOMAttributeMap.cpp | 6 +- dom/base/nsDOMAttributeMap.h | 6 +- dom/base/nsDOMDataChannel.cpp | 4 +- dom/base/nsDOMDataChannel.h | 4 +- dom/base/nsDOMMutationObserver.cpp | 8 +- dom/base/nsDOMMutationObserver.h | 20 +- dom/base/nsDOMTokenList.cpp | 10 +- dom/base/nsDOMTokenList.h | 8 +- dom/base/nsDOMWindowUtils.cpp | 4 +- dom/base/nsDocument.cpp | 44 ++-- dom/base/nsDocument.h | 24 +- dom/base/nsFrameLoader.cpp | 2 +- dom/base/nsFrameLoader.h | 2 +- dom/base/nsFrameMessageManager.h | 2 +- dom/base/nsGenericDOMDataNode.cpp | 14 +- dom/base/nsGenericDOMDataNode.h | 14 +- dom/base/nsGkAtoms.cpp | 2 +- dom/base/nsGkAtoms.h | 4 +- dom/base/nsGlobalWindow.cpp | 4 +- dom/base/nsGlobalWindow.h | 4 +- dom/base/nsHTMLContentSerializer.cpp | 8 +- dom/base/nsHTMLContentSerializer.h | 4 +- dom/base/nsIContent.h | 42 ++-- dom/base/nsIContentInlines.h | 4 +- dom/base/nsIDocument.h | 26 +-- dom/base/nsIMutationObserver.h | 16 +- dom/base/nsINode.cpp | 22 +- dom/base/nsINode.h | 26 +-- dom/base/nsIdentifierMapEntry.h | 6 +- dom/base/nsJSEnvironment.cpp | 4 +- dom/base/nsLineBreaker.cpp | 6 +- dom/base/nsLineBreaker.h | 10 +- dom/base/nsMappedAttributeElement.cpp | 2 +- dom/base/nsMappedAttributeElement.h | 2 +- dom/base/nsMappedAttributes.cpp | 6 +- dom/base/nsMappedAttributes.h | 8 +- dom/base/nsNameSpaceManager.cpp | 14 +- dom/base/nsNameSpaceManager.h | 18 +- dom/base/nsNodeInfoManager.cpp | 14 +- dom/base/nsNodeInfoManager.h | 12 +- dom/base/nsNodeUtils.cpp | 12 +- dom/base/nsNodeUtils.h | 6 +- dom/base/nsObjectLoadingContent.cpp | 2 +- dom/base/nsPlainTextSerializer.cpp | 26 +-- dom/base/nsPlainTextSerializer.h | 18 +- dom/base/nsPropertyTable.cpp | 22 +- dom/base/nsPropertyTable.h | 22 +- dom/base/nsStyledElement.cpp | 4 +- dom/base/nsStyledElement.h | 4 +- dom/base/nsTextNode.cpp | 8 +- dom/base/nsTreeSanitizer.cpp | 78 +++---- dom/base/nsTreeSanitizer.h | 26 +-- dom/base/nsXHTMLContentSerializer.cpp | 18 +- dom/base/nsXHTMLContentSerializer.h | 16 +- dom/base/nsXMLContentSerializer.cpp | 28 +-- dom/base/nsXMLContentSerializer.h | 18 +- dom/base/nsXMLNameSpaceMap.cpp | 12 +- dom/base/nsXMLNameSpaceMap.h | 14 +- dom/bindings/DOMString.h | 4 +- dom/canvas/CanvasRenderingContext2D.cpp | 4 +- dom/canvas/CanvasRenderingContext2D.h | 2 +- dom/events/CommandEvent.cpp | 2 +- dom/events/ContentEventHandler.cpp | 2 +- dom/events/DOMEventTargetHelper.cpp | 8 +- dom/events/DOMEventTargetHelper.h | 12 +- dom/events/DataTransfer.cpp | 4 +- dom/events/EventListenerManager.cpp | 32 +-- dom/events/EventListenerManager.h | 32 +-- dom/events/EventListenerService.cpp | 6 +- dom/events/EventListenerService.h | 8 +- dom/events/EventStateManager.cpp | 2 +- dom/events/EventTarget.cpp | 6 +- dom/events/EventTarget.h | 12 +- dom/events/IMEContentObserver.cpp | 6 +- dom/events/InternalMutationEvent.h | 8 +- dom/events/JSEventHandler.cpp | 4 +- dom/events/JSEventHandler.h | 10 +- dom/html/HTMLAllCollection.cpp | 10 +- dom/html/HTMLAnchorElement.cpp | 4 +- dom/html/HTMLAnchorElement.h | 4 +- dom/html/HTMLAreaElement.cpp | 2 +- dom/html/HTMLAreaElement.h | 2 +- dom/html/HTMLBRElement.cpp | 4 +- dom/html/HTMLBRElement.h | 4 +- dom/html/HTMLBodyElement.cpp | 8 +- dom/html/HTMLBodyElement.h | 8 +- dom/html/HTMLButtonElement.cpp | 6 +- dom/html/HTMLButtonElement.h | 6 +- dom/html/HTMLCanvasElement.cpp | 10 +- dom/html/HTMLCanvasElement.h | 10 +- dom/html/HTMLContentElement.cpp | 4 +- dom/html/HTMLContentElement.h | 2 +- dom/html/HTMLDataListElement.cpp | 2 +- dom/html/HTMLDataListElement.h | 2 +- dom/html/HTMLDetailsElement.cpp | 4 +- dom/html/HTMLDetailsElement.h | 4 +- dom/html/HTMLDivElement.cpp | 4 +- dom/html/HTMLDivElement.h | 4 +- dom/html/HTMLEmbedElement.cpp | 10 +- dom/html/HTMLEmbedElement.h | 10 +- dom/html/HTMLFieldSetElement.cpp | 4 +- dom/html/HTMLFieldSetElement.h | 4 +- dom/html/HTMLFontElement.cpp | 4 +- dom/html/HTMLFontElement.h | 4 +- dom/html/HTMLFormElement.cpp | 6 +- dom/html/HTMLFormElement.h | 6 +- dom/html/HTMLFormSubmission.cpp | 2 +- dom/html/HTMLFrameElement.cpp | 2 +- dom/html/HTMLFrameElement.h | 2 +- dom/html/HTMLFrameSetElement.cpp | 8 +- dom/html/HTMLFrameSetElement.h | 8 +- dom/html/HTMLHRElement.cpp | 4 +- dom/html/HTMLHRElement.h | 4 +- dom/html/HTMLHeadingElement.cpp | 4 +- dom/html/HTMLHeadingElement.h | 4 +- dom/html/HTMLIFrameElement.cpp | 10 +- dom/html/HTMLIFrameElement.h | 10 +- dom/html/HTMLImageElement.cpp | 14 +- dom/html/HTMLImageElement.h | 14 +- dom/html/HTMLInputElement.cpp | 10 +- dom/html/HTMLInputElement.h | 10 +- dom/html/HTMLLIElement.cpp | 4 +- dom/html/HTMLLIElement.h | 4 +- dom/html/HTMLLegendElement.cpp | 4 +- dom/html/HTMLLegendElement.h | 4 +- dom/html/HTMLLinkElement.cpp | 6 +- dom/html/HTMLLinkElement.h | 6 +- dom/html/HTMLMediaElement.cpp | 10 +- dom/html/HTMLMediaElement.h | 10 +- dom/html/HTMLMenuElement.cpp | 4 +- dom/html/HTMLMenuElement.h | 4 +- dom/html/HTMLMenuItemElement.cpp | 4 +- dom/html/HTMLMenuItemElement.h | 4 +- dom/html/HTMLMetaElement.cpp | 2 +- dom/html/HTMLMetaElement.h | 2 +- dom/html/HTMLMeterElement.cpp | 2 +- dom/html/HTMLMeterElement.h | 2 +- dom/html/HTMLObjectElement.cpp | 10 +- dom/html/HTMLObjectElement.h | 10 +- dom/html/HTMLOptGroupElement.cpp | 2 +- dom/html/HTMLOptGroupElement.h | 2 +- dom/html/HTMLOptionElement.cpp | 6 +- dom/html/HTMLOptionElement.h | 6 +- dom/html/HTMLOptionsCollection.cpp | 6 +- dom/html/HTMLOutputElement.cpp | 2 +- dom/html/HTMLOutputElement.h | 2 +- dom/html/HTMLParagraphElement.cpp | 4 +- dom/html/HTMLParagraphElement.h | 4 +- dom/html/HTMLPreElement.cpp | 4 +- dom/html/HTMLPreElement.h | 4 +- dom/html/HTMLProgressElement.cpp | 2 +- dom/html/HTMLProgressElement.h | 2 +- dom/html/HTMLScriptElement.cpp | 4 +- dom/html/HTMLScriptElement.h | 4 +- dom/html/HTMLSelectElement.cpp | 12 +- dom/html/HTMLSelectElement.h | 12 +- dom/html/HTMLSharedElement.cpp | 6 +- dom/html/HTMLSharedElement.h | 6 +- dom/html/HTMLSharedListElement.cpp | 4 +- dom/html/HTMLSharedListElement.h | 4 +- dom/html/HTMLSourceElement.cpp | 2 +- dom/html/HTMLSourceElement.h | 2 +- dom/html/HTMLSpanElement.cpp | 2 +- dom/html/HTMLSpanElement.h | 2 +- dom/html/HTMLStyleElement.cpp | 2 +- dom/html/HTMLStyleElement.h | 2 +- dom/html/HTMLTableCaptionElement.cpp | 4 +- dom/html/HTMLTableCaptionElement.h | 4 +- dom/html/HTMLTableCellElement.cpp | 4 +- dom/html/HTMLTableCellElement.h | 4 +- dom/html/HTMLTableColElement.cpp | 4 +- dom/html/HTMLTableColElement.h | 4 +- dom/html/HTMLTableElement.cpp | 24 +- dom/html/HTMLTableElement.h | 10 +- dom/html/HTMLTableRowElement.cpp | 6 +- dom/html/HTMLTableRowElement.h | 4 +- dom/html/HTMLTableSectionElement.cpp | 4 +- dom/html/HTMLTableSectionElement.h | 4 +- dom/html/HTMLTemplateElement.cpp | 2 +- dom/html/HTMLTextAreaElement.cpp | 10 +- dom/html/HTMLTextAreaElement.h | 10 +- dom/html/HTMLTrackElement.cpp | 2 +- dom/html/HTMLTrackElement.h | 2 +- dom/html/HTMLVideoElement.cpp | 4 +- dom/html/HTMLVideoElement.h | 4 +- dom/html/nsDOMStringMap.cpp | 6 +- dom/html/nsGenericHTMLElement.cpp | 44 ++-- dom/html/nsGenericHTMLElement.h | 62 ++--- dom/html/nsGenericHTMLFrameElement.cpp | 6 +- dom/html/nsGenericHTMLFrameElement.h | 6 +- dom/html/nsHTMLContentSink.cpp | 6 +- dom/html/nsHTMLDocument.cpp | 10 +- dom/html/nsHTMLDocument.h | 8 +- dom/mathml/nsMathMLElement.cpp | 8 +- dom/mathml/nsMathMLElement.h | 6 +- dom/media/doctor/DecoderDoctorDiagnostics.cpp | 4 +- dom/media/webaudio/ScriptProcessorNode.cpp | 4 +- dom/media/webaudio/ScriptProcessorNode.h | 4 +- dom/script/ScriptElement.cpp | 2 +- dom/smil/nsSMILAnimationController.cpp | 4 +- dom/smil/nsSMILAnimationFunction.cpp | 12 +- dom/smil/nsSMILAnimationFunction.h | 12 +- dom/smil/nsSMILCSSProperty.h | 2 +- dom/smil/nsSMILParserUtils.cpp | 6 +- dom/smil/nsSMILSetAnimationFunction.cpp | 12 +- dom/smil/nsSMILSetAnimationFunction.h | 12 +- dom/smil/nsSMILTargetIdentifier.h | 4 +- dom/smil/nsSMILTimeValueSpecParams.h | 6 +- dom/smil/nsSMILTimedElement.cpp | 4 +- dom/smil/nsSMILTimedElement.h | 6 +- dom/svg/SVGAElement.cpp | 8 +- dom/svg/SVGAElement.h | 10 +- dom/svg/SVGAnimateMotionElement.cpp | 2 +- dom/svg/SVGAnimateMotionElement.h | 4 +- dom/svg/SVGAnimateTransformElement.cpp | 4 +- dom/svg/SVGAnimateTransformElement.h | 2 +- dom/svg/SVGAnimationElement.cpp | 16 +- dom/svg/SVGAnimationElement.h | 16 +- dom/svg/SVGComponentTransferFunctionElement.h | 2 +- dom/svg/SVGDefsElement.cpp | 2 +- dom/svg/SVGDefsElement.h | 2 +- dom/svg/SVGElementFactory.cpp | 6 +- dom/svg/SVGElementFactory.h | 2 +- dom/svg/SVGFEBlendElement.cpp | 2 +- dom/svg/SVGFEBlendElement.h | 2 +- dom/svg/SVGFEColorMatrixElement.cpp | 2 +- dom/svg/SVGFEColorMatrixElement.h | 2 +- dom/svg/SVGFEComponentTransferElement.cpp | 2 +- dom/svg/SVGFEComponentTransferElement.h | 2 +- dom/svg/SVGFECompositeElement.cpp | 2 +- dom/svg/SVGFECompositeElement.h | 2 +- dom/svg/SVGFEConvolveMatrixElement.cpp | 2 +- dom/svg/SVGFEConvolveMatrixElement.h | 2 +- dom/svg/SVGFEDiffuseLightingElement.cpp | 2 +- dom/svg/SVGFEDiffuseLightingElement.h | 2 +- dom/svg/SVGFEDisplacementMapElement.cpp | 2 +- dom/svg/SVGFEDisplacementMapElement.h | 2 +- dom/svg/SVGFEDistantLightElement.cpp | 2 +- dom/svg/SVGFEDistantLightElement.h | 2 +- dom/svg/SVGFEDropShadowElement.cpp | 4 +- dom/svg/SVGFEDropShadowElement.h | 4 +- dom/svg/SVGFEFloodElement.cpp | 2 +- dom/svg/SVGFEFloodElement.h | 2 +- dom/svg/SVGFEGaussianBlurElement.cpp | 2 +- dom/svg/SVGFEGaussianBlurElement.h | 2 +- dom/svg/SVGFEImageElement.cpp | 6 +- dom/svg/SVGFEImageElement.h | 6 +- dom/svg/SVGFEMergeNodeElement.cpp | 2 +- dom/svg/SVGFEMergeNodeElement.h | 2 +- dom/svg/SVGFEMorphologyElement.cpp | 2 +- dom/svg/SVGFEMorphologyElement.h | 2 +- dom/svg/SVGFEOffsetElement.cpp | 2 +- dom/svg/SVGFEOffsetElement.h | 2 +- dom/svg/SVGFEPointLightElement.cpp | 2 +- dom/svg/SVGFEPointLightElement.h | 2 +- dom/svg/SVGFESpecularLightingElement.cpp | 2 +- dom/svg/SVGFESpecularLightingElement.h | 2 +- dom/svg/SVGFESpotLightElement.cpp | 2 +- dom/svg/SVGFESpotLightElement.h | 2 +- dom/svg/SVGFETileElement.cpp | 2 +- dom/svg/SVGFETileElement.h | 2 +- dom/svg/SVGFETurbulenceElement.cpp | 2 +- dom/svg/SVGFETurbulenceElement.h | 2 +- dom/svg/SVGFilterElement.cpp | 2 +- dom/svg/SVGFilterElement.h | 2 +- dom/svg/SVGForeignObjectElement.cpp | 2 +- dom/svg/SVGForeignObjectElement.h | 2 +- dom/svg/SVGFragmentIdentifier.cpp | 2 +- dom/svg/SVGGElement.cpp | 2 +- dom/svg/SVGGElement.h | 2 +- dom/svg/SVGGeometryElement.cpp | 4 +- dom/svg/SVGGeometryElement.h | 4 +- dom/svg/SVGGradientElement.cpp | 2 +- dom/svg/SVGGradientElement.h | 4 +- dom/svg/SVGImageElement.cpp | 4 +- dom/svg/SVGImageElement.h | 4 +- dom/svg/SVGLength.cpp | 4 +- dom/svg/SVGLineElement.cpp | 2 +- dom/svg/SVGLineElement.h | 2 +- dom/svg/SVGMPathElement.cpp | 6 +- dom/svg/SVGMPathElement.h | 4 +- dom/svg/SVGMarkerElement.cpp | 6 +- dom/svg/SVGMarkerElement.h | 6 +- dom/svg/SVGMaskElement.cpp | 2 +- dom/svg/SVGMaskElement.h | 2 +- dom/svg/SVGMotionSMILAnimationFunction.cpp | 6 +- dom/svg/SVGMotionSMILAnimationFunction.h | 8 +- dom/svg/SVGPathElement.cpp | 4 +- dom/svg/SVGPathElement.h | 6 +- dom/svg/SVGPatternElement.cpp | 2 +- dom/svg/SVGPatternElement.h | 4 +- dom/svg/SVGPolyElement.cpp | 4 +- dom/svg/SVGPolyElement.h | 6 +- dom/svg/SVGSVGElement.cpp | 2 +- dom/svg/SVGSVGElement.h | 2 +- dom/svg/SVGScriptElement.cpp | 4 +- dom/svg/SVGScriptElement.h | 4 +- dom/svg/SVGStopElement.cpp | 2 +- dom/svg/SVGStopElement.h | 2 +- dom/svg/SVGStyleElement.cpp | 8 +- dom/svg/SVGStyleElement.h | 10 +- dom/svg/SVGSwitchElement.cpp | 2 +- dom/svg/SVGSwitchElement.h | 2 +- dom/svg/SVGTSpanElement.cpp | 2 +- dom/svg/SVGTSpanElement.h | 2 +- dom/svg/SVGTests.cpp | 10 +- dom/svg/SVGTests.h | 12 +- dom/svg/SVGTextElement.cpp | 2 +- dom/svg/SVGTextElement.h | 2 +- dom/svg/SVGTextPathElement.cpp | 2 +- dom/svg/SVGTextPathElement.h | 4 +- dom/svg/SVGTransformListParser.cpp | 4 +- dom/svg/SVGTransformableElement.cpp | 6 +- dom/svg/SVGTransformableElement.h | 8 +- dom/svg/SVGUseElement.cpp | 6 +- dom/svg/SVGUseElement.h | 4 +- dom/svg/SVGViewportElement.cpp | 2 +- dom/svg/SVGViewportElement.h | 2 +- dom/svg/nsSVGAngle.cpp | 4 +- dom/svg/nsSVGAnimatedTransformList.cpp | 4 +- dom/svg/nsSVGAnimatedTransformList.h | 4 +- dom/svg/nsSVGBoolean.cpp | 6 +- dom/svg/nsSVGBoolean.h | 6 +- dom/svg/nsSVGElement.cpp | 50 ++-- dom/svg/nsSVGElement.h | 62 ++--- dom/svg/nsSVGEnum.cpp | 8 +- dom/svg/nsSVGEnum.h | 8 +- dom/svg/nsSVGFilters.cpp | 10 +- dom/svg/nsSVGFilters.h | 10 +- dom/svg/nsSVGLength2.cpp | 4 +- dom/xbl/XBLChildrenElement.cpp | 2 +- dom/xbl/XBLChildrenElement.h | 4 +- dom/xbl/nsBindingManager.cpp | 4 +- dom/xbl/nsBindingManager.h | 4 +- dom/xbl/nsXBLBinding.cpp | 14 +- dom/xbl/nsXBLBinding.h | 6 +- dom/xbl/nsXBLContentSink.cpp | 22 +- dom/xbl/nsXBLContentSink.h | 6 +- dom/xbl/nsXBLEventHandler.cpp | 6 +- dom/xbl/nsXBLEventHandler.h | 10 +- dom/xbl/nsXBLProtoImplField.cpp | 2 +- dom/xbl/nsXBLProtoImplField.h | 2 +- dom/xbl/nsXBLProtoImplMember.h | 2 +- dom/xbl/nsXBLProtoImplMethod.cpp | 2 +- dom/xbl/nsXBLProtoImplMethod.h | 2 +- dom/xbl/nsXBLProtoImplProperty.cpp | 2 +- dom/xbl/nsXBLProtoImplProperty.h | 2 +- dom/xbl/nsXBLPrototypeBinding.cpp | 66 +++--- dom/xbl/nsXBLPrototypeBinding.h | 20 +- dom/xbl/nsXBLPrototypeHandler.cpp | 10 +- dom/xbl/nsXBLPrototypeHandler.h | 14 +- dom/xbl/nsXBLPrototypeResources.cpp | 2 +- dom/xbl/nsXBLPrototypeResources.h | 4 +- dom/xbl/nsXBLResourceLoader.cpp | 6 +- dom/xbl/nsXBLResourceLoader.h | 4 +- dom/xbl/nsXBLWindowKeyHandler.cpp | 14 +- dom/xbl/nsXBLWindowKeyHandler.h | 10 +- dom/xml/ProcessingInstruction.cpp | 4 +- dom/xml/ProcessingInstruction.h | 2 +- dom/xml/nsXMLContentSink.cpp | 10 +- dom/xml/nsXMLContentSink.h | 4 +- dom/xml/nsXMLElement.cpp | 2 +- dom/xml/nsXMLFragmentContentSink.cpp | 4 +- dom/xml/nsXMLPrettyPrinter.cpp | 2 +- dom/xslt/base/txExpandedName.cpp | 2 +- dom/xslt/base/txExpandedName.h | 6 +- dom/xslt/base/txExpandedNameMap.h | 2 +- dom/xslt/base/txNamespaceMap.cpp | 10 +- dom/xslt/base/txNamespaceMap.h | 8 +- dom/xslt/base/txStringUtils.h | 8 +- dom/xslt/xml/txXMLUtils.cpp | 8 +- dom/xslt/xml/txXMLUtils.h | 8 +- dom/xslt/xpath/XPathEvaluator.cpp | 12 +- dom/xslt/xpath/XPathExpression.cpp | 2 +- dom/xslt/xpath/XPathResult.cpp | 2 +- dom/xslt/xpath/txCoreFunctionCall.cpp | 6 +- dom/xslt/xpath/txExpr.h | 32 +-- dom/xslt/xpath/txExprParser.cpp | 12 +- dom/xslt/xpath/txExprParser.h | 6 +- dom/xslt/xpath/txForwardContext.cpp | 2 +- dom/xslt/xpath/txFunctionCall.cpp | 4 +- dom/xslt/xpath/txIXPathContext.h | 10 +- dom/xslt/xpath/txMozillaXPathTreeWalker.cpp | 14 +- dom/xslt/xpath/txNameTest.cpp | 4 +- dom/xslt/xpath/txNamedAttributeStep.cpp | 6 +- dom/xslt/xpath/txNodeSetContext.cpp | 2 +- dom/xslt/xpath/txNodeTypeTest.cpp | 2 +- dom/xslt/xpath/txSingleNodeContext.h | 2 +- dom/xslt/xpath/txVariableRefExpr.cpp | 4 +- dom/xslt/xpath/txXPCOMExtensionFunction.cpp | 14 +- dom/xslt/xpath/txXPathOptimizer.cpp | 4 +- dom/xslt/xpath/txXPathTreeWalker.h | 20 +- dom/xslt/xslt/txBufferingHandler.cpp | 40 ++-- dom/xslt/xslt/txCurrentFunctionCall.cpp | 2 +- dom/xslt/xslt/txDocumentFunctionCall.cpp | 2 +- dom/xslt/xslt/txEXSLTFunctions.cpp | 10 +- dom/xslt/xslt/txExecutionState.cpp | 2 +- dom/xslt/xslt/txExecutionState.h | 2 +- dom/xslt/xslt/txFormatNumberFunctionCall.cpp | 2 +- dom/xslt/xslt/txGenerateIdFunctionCall.cpp | 2 +- dom/xslt/xslt/txInstructions.cpp | 18 +- dom/xslt/xslt/txInstructions.h | 22 +- dom/xslt/xslt/txKeyFunctionCall.cpp | 2 +- dom/xslt/xslt/txMozillaTextOutput.cpp | 14 +- dom/xslt/xslt/txMozillaTextOutput.h | 2 +- dom/xslt/xslt/txMozillaXMLOutput.cpp | 38 +-- dom/xslt/xslt/txMozillaXMLOutput.h | 10 +- dom/xslt/xslt/txMozillaXSLTProcessor.cpp | 18 +- dom/xslt/xslt/txPatternParser.cpp | 6 +- dom/xslt/xslt/txStylesheet.h | 2 +- dom/xslt/xslt/txStylesheetCompileHandlers.cpp | 218 +++++++++--------- dom/xslt/xslt/txStylesheetCompileHandlers.h | 6 +- dom/xslt/xslt/txStylesheetCompiler.cpp | 34 +-- dom/xslt/xslt/txStylesheetCompiler.h | 20 +- dom/xslt/xslt/txTextHandler.cpp | 12 +- dom/xslt/xslt/txUnknownHandler.cpp | 14 +- dom/xslt/xslt/txXMLEventHandler.h | 30 +-- .../xslt/txXSLTEnvironmentFunctionCall.cpp | 4 +- dom/xslt/xslt/txXSLTNumber.cpp | 2 +- dom/xslt/xslt/txXSLTPatterns.cpp | 4 +- dom/xslt/xslt/txXSLTPatterns.h | 6 +- dom/xul/XULDocument.cpp | 64 ++--- dom/xul/XULDocument.h | 18 +- dom/xul/nsXULContentSink.cpp | 4 +- dom/xul/nsXULElement.cpp | 34 +-- dom/xul/nsXULElement.h | 28 +-- dom/xul/nsXULPopupListener.cpp | 4 +- dom/xul/nsXULPrototypeDocument.cpp | 6 +- dom/xul/nsXULPrototypeDocument.h | 6 +- dom/xul/templates/nsContentTestNode.cpp | 4 +- dom/xul/templates/nsContentTestNode.h | 10 +- dom/xul/templates/nsIXULTemplateBuilder.idl | 4 +- .../nsIXULTemplateQueryProcessor.idl | 12 +- dom/xul/templates/nsIXULTemplateResult.idl | 6 +- dom/xul/templates/nsRDFBinding.cpp | 8 +- dom/xul/templates/nsRDFBinding.h | 18 +- .../templates/nsRDFConInstanceTestNode.cpp | 2 +- dom/xul/templates/nsRDFConInstanceTestNode.h | 4 +- dom/xul/templates/nsRDFConMemberTestNode.cpp | 6 +- dom/xul/templates/nsRDFConMemberTestNode.h | 8 +- dom/xul/templates/nsRDFPropertyTestNode.cpp | 10 +- dom/xul/templates/nsRDFPropertyTestNode.h | 12 +- dom/xul/templates/nsRDFQuery.h | 8 +- dom/xul/templates/nsRuleNetwork.cpp | 8 +- dom/xul/templates/nsRuleNetwork.h | 16 +- dom/xul/templates/nsTemplateRule.cpp | 16 +- dom/xul/templates/nsTemplateRule.h | 46 ++-- dom/xul/templates/nsXMLBinding.cpp | 4 +- dom/xul/templates/nsXMLBinding.h | 12 +- dom/xul/templates/nsXULContentBuilder.cpp | 18 +- dom/xul/templates/nsXULContentUtils.cpp | 4 +- dom/xul/templates/nsXULContentUtils.h | 6 +- dom/xul/templates/nsXULSortService.cpp | 8 +- dom/xul/templates/nsXULSortService.h | 2 +- dom/xul/templates/nsXULTemplateBuilder.cpp | 44 ++-- dom/xul/templates/nsXULTemplateBuilder.h | 10 +- .../nsXULTemplateQueryProcessorRDF.cpp | 24 +- .../nsXULTemplateQueryProcessorRDF.h | 4 +- .../nsXULTemplateQueryProcessorStorage.cpp | 14 +- .../nsXULTemplateQueryProcessorStorage.h | 4 +- .../nsXULTemplateQueryProcessorXML.cpp | 12 +- .../nsXULTemplateQueryProcessorXML.h | 8 +- dom/xul/templates/nsXULTemplateResultRDF.cpp | 6 +- dom/xul/templates/nsXULTemplateResultRDF.h | 2 +- .../templates/nsXULTemplateResultStorage.cpp | 4 +- dom/xul/templates/nsXULTemplateResultXML.cpp | 6 +- dom/xul/templates/nsXULTreeBuilder.cpp | 2 +- dom/xul/templates/nsXULTreeBuilder.h | 2 +- editor/composer/nsComposerCommands.cpp | 16 +- editor/composer/nsComposerCommands.h | 16 +- editor/libeditor/CSSEditUtils.cpp | 88 +++---- editor/libeditor/CSSEditUtils.h | 70 +++--- .../libeditor/ChangeAttributeTransaction.cpp | 2 +- editor/libeditor/ChangeAttributeTransaction.h | 6 +- editor/libeditor/ChangeStyleTransaction.cpp | 4 +- editor/libeditor/ChangeStyleTransaction.h | 8 +- editor/libeditor/CreateElementTransaction.cpp | 2 +- editor/libeditor/CreateElementTransaction.h | 6 +- editor/libeditor/EditAggregateTransaction.cpp | 2 +- editor/libeditor/EditAggregateTransaction.h | 6 +- editor/libeditor/EditorBase.cpp | 54 ++--- editor/libeditor/EditorBase.h | 46 ++-- editor/libeditor/EditorUtils.h | 6 +- editor/libeditor/HTMLAnonymousNodeEditor.cpp | 6 +- editor/libeditor/HTMLEditRules.cpp | 54 ++--- editor/libeditor/HTMLEditRules.h | 20 +- editor/libeditor/HTMLEditUtils.cpp | 4 +- editor/libeditor/HTMLEditor.cpp | 18 +- editor/libeditor/HTMLEditor.h | 44 ++-- editor/libeditor/HTMLEditorDataTransfer.cpp | 6 +- editor/libeditor/HTMLEditorObjectResizer.cpp | 6 +- editor/libeditor/HTMLStyleEditor.cpp | 54 ++--- editor/libeditor/HTMLTableEditor.cpp | 6 +- editor/libeditor/HTMLURIRefObject.cpp | 2 +- editor/libeditor/PlaceholderTransaction.cpp | 6 +- editor/libeditor/PlaceholderTransaction.h | 4 +- editor/libeditor/TextEditor.cpp | 4 +- editor/libeditor/TextEditor.h | 4 +- editor/libeditor/TypeInState.cpp | 26 +-- editor/libeditor/TypeInState.h | 28 +-- editor/libeditor/nsIAbsorbingTransaction.h | 4 +- editor/txtsvc/nsFilteredContentIterator.cpp | 2 +- editor/txtsvc/nsFilteredContentIterator.h | 12 +- editor/txtsvc/nsTSAtomList.h | 2 +- editor/txtsvc/nsTextServicesDocument.cpp | 4 +- editor/txtsvc/nsTextServicesDocument.h | 54 ++--- .../spellcheck/src/mozInlineSpellWordUtil.cpp | 2 +- gfx/src/nsDeviceContext.cpp | 6 +- gfx/src/nsDeviceContext.h | 2 +- gfx/src/nsFontMetrics.cpp | 2 +- gfx/src/nsFontMetrics.h | 8 +- gfx/src/nsITheme.h | 4 +- gfx/src/nsThebesFontEnumerator.cpp | 10 +- gfx/thebes/gfxDWriteFontList.h | 2 +- gfx/thebes/gfxFcPlatformFontList.cpp | 14 +- gfx/thebes/gfxFcPlatformFontList.h | 10 +- gfx/thebes/gfxFont.cpp | 2 +- gfx/thebes/gfxFont.h | 8 +- gfx/thebes/gfxFontEntry.h | 4 +- gfx/thebes/gfxGDIFontList.h | 4 +- gfx/thebes/gfxPlatform.cpp | 2 +- gfx/thebes/gfxPlatform.h | 4 +- gfx/thebes/gfxPlatformFontList.cpp | 30 +-- gfx/thebes/gfxPlatformFontList.h | 16 +- gfx/thebes/gfxPlatformGtk.cpp | 2 +- gfx/thebes/gfxPlatformGtk.h | 2 +- gfx/thebes/gfxTextRun.h | 2 +- .../hyphenation/glue/nsHyphenationManager.cpp | 16 +- intl/hyphenation/glue/nsHyphenationManager.h | 10 +- intl/locale/nsLanguageAtomService.cpp | 26 +-- intl/locale/nsLanguageAtomService.h | 16 +- .../rootAnalysis/analyzeHeapWrites.js | 2 +- js/src/devtools/rootAnalysis/annotations.js | 2 +- layout/base/GeckoRestyleManager.cpp | 16 +- layout/base/GeckoRestyleManager.h | 4 +- layout/base/PositionedEventTargeting.cpp | 2 +- layout/base/PresShell.cpp | 6 +- layout/base/RestyleManager.cpp | 2 +- layout/base/RestyleManager.h | 4 +- layout/base/RestyleManagerInlines.h | 4 +- layout/base/ServoRestyleManager.cpp | 12 +- layout/base/ServoRestyleManager.h | 8 +- layout/base/StaticPresData.cpp | 20 +- layout/base/StaticPresData.h | 18 +- layout/base/nsCSSFrameConstructor.cpp | 52 ++--- layout/base/nsCSSFrameConstructor.h | 34 +-- layout/base/nsGenConList.cpp | 2 +- layout/base/nsLayoutUtils.cpp | 22 +- layout/base/nsLayoutUtils.h | 16 +- layout/base/nsPresContext.cpp | 10 +- layout/base/nsPresContext.h | 30 +-- layout/forms/nsCheckboxRadioFrame.cpp | 2 +- layout/forms/nsCheckboxRadioFrame.h | 2 +- layout/forms/nsColorControlFrame.cpp | 2 +- layout/forms/nsColorControlFrame.h | 2 +- layout/forms/nsComboboxControlFrame.cpp | 4 +- layout/forms/nsComboboxControlFrame.h | 2 +- layout/forms/nsDateTimeControlFrame.cpp | 2 +- layout/forms/nsDateTimeControlFrame.h | 2 +- layout/forms/nsFileControlFrame.cpp | 4 +- layout/forms/nsFileControlFrame.h | 4 +- layout/forms/nsGfxButtonControlFrame.cpp | 2 +- layout/forms/nsGfxButtonControlFrame.h | 2 +- layout/forms/nsHTMLButtonControlFrame.cpp | 2 +- layout/forms/nsHTMLButtonControlFrame.h | 2 +- layout/forms/nsIFormControlFrame.h | 4 +- layout/forms/nsImageControlFrame.cpp | 4 +- layout/forms/nsListControlFrame.cpp | 2 +- layout/forms/nsListControlFrame.h | 2 +- layout/forms/nsMeterFrame.cpp | 2 +- layout/forms/nsMeterFrame.h | 2 +- layout/forms/nsNumberControlFrame.cpp | 6 +- layout/forms/nsNumberControlFrame.h | 6 +- layout/forms/nsProgressFrame.cpp | 2 +- layout/forms/nsProgressFrame.h | 2 +- layout/forms/nsRangeFrame.cpp | 2 +- layout/forms/nsRangeFrame.h | 2 +- layout/forms/nsTextControlFrame.cpp | 4 +- layout/forms/nsTextControlFrame.h | 6 +- layout/generic/RubyUtils.h | 2 +- layout/generic/ScrollbarActivity.cpp | 2 +- layout/generic/TextOverflow.cpp | 2 +- layout/generic/ViewportFrame.cpp | 2 +- layout/generic/nsBlockFrame.cpp | 4 +- layout/generic/nsBlockFrame.h | 2 +- layout/generic/nsContainerFrame.cpp | 4 +- layout/generic/nsContainerFrame.h | 2 +- layout/generic/nsFrame.cpp | 22 +- layout/generic/nsFrame.h | 4 +- layout/generic/nsFrameSelection.cpp | 6 +- layout/generic/nsFrameSetFrame.h | 2 +- layout/generic/nsGfxScrollFrame.cpp | 24 +- layout/generic/nsGfxScrollFrame.h | 40 ++-- layout/generic/nsHTMLParts.h | 4 +- layout/generic/nsIFrame.h | 4 +- layout/generic/nsIScrollableFrame.h | 10 +- layout/generic/nsImageFrame.cpp | 2 +- layout/generic/nsImageFrame.h | 2 +- layout/generic/nsImageMap.cpp | 2 +- layout/generic/nsInlineFrame.cpp | 2 +- layout/generic/nsInlineFrame.h | 2 +- layout/generic/nsRubyContentFrame.cpp | 2 +- layout/generic/nsSubDocumentFrame.cpp | 2 +- layout/generic/nsSubDocumentFrame.h | 2 +- layout/generic/nsTextFrame.cpp | 6 +- layout/generic/nsTextRunTransformations.cpp | 12 +- layout/generic/nsTextRunTransformations.h | 4 +- layout/generic/nsVideoFrame.cpp | 2 +- layout/generic/nsVideoFrame.h | 2 +- layout/inspector/inDOMUtils.cpp | 12 +- layout/inspector/inDOMUtils.h | 4 +- layout/inspector/inDOMView.cpp | 2 +- layout/mathml/nsMathMLContainerFrame.cpp | 4 +- layout/mathml/nsMathMLContainerFrame.h | 4 +- layout/mathml/nsMathMLmactionFrame.cpp | 2 +- layout/mathml/nsMathMLmactionFrame.h | 2 +- layout/mathml/nsMathMLmencloseFrame.cpp | 2 +- layout/mathml/nsMathMLmencloseFrame.h | 2 +- layout/mathml/nsMathMLmfencedFrame.cpp | 2 +- layout/mathml/nsMathMLmfencedFrame.h | 2 +- layout/mathml/nsMathMLmfracFrame.cpp | 2 +- layout/mathml/nsMathMLmfracFrame.h | 2 +- layout/mathml/nsMathMLmmultiscriptsFrame.cpp | 2 +- layout/mathml/nsMathMLmoFrame.cpp | 2 +- layout/mathml/nsMathMLmoFrame.h | 2 +- layout/mathml/nsMathMLmrowFrame.cpp | 2 +- layout/mathml/nsMathMLmrowFrame.h | 2 +- layout/mathml/nsMathMLmsqrtFrame.cpp | 2 +- layout/mathml/nsMathMLmsqrtFrame.h | 2 +- layout/mathml/nsMathMLmtableFrame.cpp | 18 +- layout/mathml/nsMathMLmtableFrame.h | 6 +- layout/mathml/nsMathMLmunderoverFrame.cpp | 2 +- layout/mathml/nsMathMLmunderoverFrame.h | 2 +- layout/style/AnimationCollection.cpp | 10 +- layout/style/AnimationCollection.h | 10 +- layout/style/CSSNamespaceRule.h | 4 +- layout/style/CSSStyleSheet.cpp | 2 +- layout/style/CounterStyleManager.cpp | 24 +- layout/style/CounterStyleManager.h | 26 +-- layout/style/GeckoStyleContext.cpp | 4 +- layout/style/GeckoStyleContext.h | 4 +- layout/style/GenericSpecifiedValues.h | 4 +- layout/style/GenericSpecifiedValuesInlines.h | 4 +- layout/style/NameSpaceRule.h | 8 +- layout/style/ServoBindingList.h | 20 +- layout/style/ServoBindings.cpp | 146 ++++++------ layout/style/ServoBindings.h | 92 ++++---- layout/style/ServoBindings.toml | 4 +- layout/style/ServoElementSnapshot.cpp | 2 +- layout/style/ServoElementSnapshot.h | 8 +- layout/style/ServoKeyframesRule.cpp | 6 +- layout/style/ServoNamespaceRule.cpp | 4 +- layout/style/ServoNamespaceRule.h | 2 +- layout/style/ServoSpecifiedValues.cpp | 4 +- layout/style/ServoSpecifiedValues.h | 2 +- layout/style/ServoStyleContext.cpp | 4 +- layout/style/ServoStyleContext.h | 6 +- layout/style/ServoStyleRule.cpp | 2 +- layout/style/ServoStyleSet.cpp | 16 +- layout/style/ServoStyleSet.h | 16 +- layout/style/StyleRule.cpp | 14 +- layout/style/StyleRule.h | 18 +- layout/style/StyleSetHandle.h | 8 +- layout/style/StyleSetHandleInlines.h | 6 +- layout/style/nsAnimationManager.h | 6 +- layout/style/nsCSSAnonBoxList.h | 2 +- layout/style/nsCSSAnonBoxes.cpp | 12 +- layout/style/nsCSSAnonBoxes.h | 22 +- layout/style/nsCSSCounterStyleRule.h | 6 +- layout/style/nsCSSParser.cpp | 40 ++-- layout/style/nsCSSParser.h | 2 +- layout/style/nsCSSPseudoClassList.h | 2 +- layout/style/nsCSSPseudoClasses.cpp | 4 +- layout/style/nsCSSPseudoClasses.h | 4 +- layout/style/nsCSSPseudoElementList.h | 2 +- layout/style/nsCSSPseudoElements.cpp | 14 +- layout/style/nsCSSPseudoElements.h | 16 +- layout/style/nsCSSRuleProcessor.cpp | 64 ++--- layout/style/nsCSSRuleProcessor.h | 6 +- layout/style/nsCSSRules.cpp | 6 +- layout/style/nsCSSValue.cpp | 4 +- layout/style/nsCSSValue.h | 10 +- layout/style/nsComputedDOMStyle.cpp | 16 +- layout/style/nsComputedDOMStyle.h | 10 +- layout/style/nsHTMLStyleSheet.cpp | 12 +- layout/style/nsHTMLStyleSheet.h | 8 +- layout/style/nsMediaFeatures.cpp | 2 +- layout/style/nsMediaFeatures.h | 8 +- layout/style/nsMediaList.h | 10 +- layout/style/nsRuleData.h | 4 +- layout/style/nsRuleNode.cpp | 14 +- layout/style/nsRuleProcessorData.h | 16 +- layout/style/nsStyleContext.cpp | 4 +- layout/style/nsStyleContext.h | 10 +- layout/style/nsStyleSet.cpp | 16 +- layout/style/nsStyleSet.h | 10 +- layout/style/nsStyleStruct.cpp | 14 +- layout/style/nsStyleStruct.h | 20 +- layout/style/nsStyleUtil.h | 2 +- layout/style/nsTransitionManager.h | 6 +- layout/svg/SVGFEContainerFrame.cpp | 4 +- layout/svg/SVGFEImageFrame.cpp | 4 +- layout/svg/SVGFELeafFrame.cpp | 4 +- layout/svg/SVGFEUnstyledLeafFrame.cpp | 4 +- layout/svg/SVGGeometryFrame.cpp | 2 +- layout/svg/SVGGeometryFrame.h | 4 +- layout/svg/SVGObserverUtils.cpp | 2 +- layout/svg/SVGObserverUtils.h | 2 +- layout/svg/SVGTextFrame.cpp | 8 +- layout/svg/SVGTextFrame.h | 4 +- layout/svg/SVGViewFrame.cpp | 4 +- layout/svg/nsSVGAFrame.cpp | 4 +- layout/svg/nsSVGClipPathFrame.cpp | 2 +- layout/svg/nsSVGClipPathFrame.h | 2 +- layout/svg/nsSVGFilterFrame.cpp | 2 +- layout/svg/nsSVGFilterFrame.h | 4 +- layout/svg/nsSVGForeignObjectFrame.cpp | 2 +- layout/svg/nsSVGForeignObjectFrame.h | 2 +- layout/svg/nsSVGGFrame.cpp | 2 +- layout/svg/nsSVGGFrame.h | 2 +- layout/svg/nsSVGGenericContainerFrame.cpp | 2 +- layout/svg/nsSVGGenericContainerFrame.h | 4 +- layout/svg/nsSVGGradientFrame.cpp | 6 +- layout/svg/nsSVGGradientFrame.h | 8 +- layout/svg/nsSVGImageFrame.cpp | 2 +- layout/svg/nsSVGImageFrame.h | 2 +- layout/svg/nsSVGMarkerFrame.cpp | 2 +- layout/svg/nsSVGMarkerFrame.h | 2 +- layout/svg/nsSVGMaskFrame.cpp | 2 +- layout/svg/nsSVGMaskFrame.h | 2 +- layout/svg/nsSVGOuterSVGFrame.cpp | 2 +- layout/svg/nsSVGOuterSVGFrame.h | 2 +- layout/svg/nsSVGPatternFrame.cpp | 2 +- layout/svg/nsSVGPatternFrame.h | 2 +- layout/svg/nsSVGStopFrame.cpp | 4 +- layout/svg/nsSVGUseFrame.cpp | 2 +- layout/svg/nsSVGUseFrame.h | 2 +- layout/svg/nsSVGViewportFrame.cpp | 2 +- layout/svg/nsSVGViewportFrame.h | 2 +- layout/tables/nsTableCellFrame.cpp | 2 +- layout/tables/nsTableCellFrame.h | 2 +- layout/tables/nsTableRowGroupFrame.h | 2 +- .../src/nsLayoutDebuggingTools.cpp | 2 +- layout/xul/nsBoxFrame.cpp | 6 +- layout/xul/nsBoxFrame.h | 2 +- layout/xul/nsDeckFrame.cpp | 2 +- layout/xul/nsDeckFrame.h | 2 +- layout/xul/nsImageBoxFrame.cpp | 2 +- layout/xul/nsImageBoxFrame.h | 2 +- layout/xul/nsLeafBoxFrame.cpp | 2 +- layout/xul/nsLeafBoxFrame.h | 2 +- layout/xul/nsListBoxBodyFrame.cpp | 2 +- layout/xul/nsListBoxBodyFrame.h | 2 +- layout/xul/nsMenuBarFrame.cpp | 2 +- layout/xul/nsMenuBarFrame.h | 2 +- layout/xul/nsMenuFrame.cpp | 8 +- layout/xul/nsMenuFrame.h | 4 +- layout/xul/nsMenuPopupFrame.cpp | 8 +- layout/xul/nsMenuPopupFrame.h | 4 +- layout/xul/nsPopupSetFrame.h | 2 +- layout/xul/nsProgressMeterFrame.cpp | 2 +- layout/xul/nsProgressMeterFrame.h | 2 +- layout/xul/nsResizerFrame.h | 2 +- layout/xul/nsScrollBoxFrame.cpp | 4 +- layout/xul/nsScrollbarButtonFrame.cpp | 4 +- layout/xul/nsScrollbarButtonFrame.h | 4 +- layout/xul/nsScrollbarFrame.cpp | 2 +- layout/xul/nsScrollbarFrame.h | 2 +- layout/xul/nsSliderFrame.cpp | 8 +- layout/xul/nsSliderFrame.h | 6 +- layout/xul/nsSplitterFrame.cpp | 6 +- layout/xul/nsSplitterFrame.h | 2 +- layout/xul/nsTextBoxFrame.cpp | 4 +- layout/xul/nsTextBoxFrame.h | 4 +- layout/xul/nsXULLabelFrame.cpp | 2 +- layout/xul/nsXULLabelFrame.h | 2 +- layout/xul/nsXULTooltipListener.cpp | 2 +- layout/xul/tree/nsTreeColFrame.cpp | 2 +- layout/xul/tree/nsTreeColFrame.h | 2 +- layout/xul/tree/nsTreeColumns.h | 4 +- layout/xul/tree/nsTreeContentView.cpp | 4 +- layout/xul/tree/nsTreeStyleCache.cpp | 2 +- layout/xul/tree/nsTreeStyleCache.h | 8 +- layout/xul/tree/nsTreeUtils.cpp | 8 +- layout/xul/tree/nsTreeUtils.h | 6 +- mfbt/Attributes.h | 2 +- .../streamconv/nsStreamConverterService.cpp | 14 +- netwerk/streamconv/nsStreamConverterService.h | 4 +- parser/html/nsHtml5AtomTable.cpp | 6 +- parser/html/nsHtml5AtomTable.h | 6 +- parser/html/nsHtml5AttributeEntry.h | 12 +- parser/html/nsHtml5AttributeName.cpp | 52 ++--- parser/html/nsHtml5AttributeName.h | 34 +-- parser/html/nsHtml5ElementName.cpp | 6 +- parser/html/nsHtml5ElementName.h | 18 +- parser/html/nsHtml5Highlighter.cpp | 10 +- parser/html/nsHtml5Highlighter.h | 10 +- parser/html/nsHtml5HtmlAttributes.cpp | 10 +- parser/html/nsHtml5HtmlAttributes.h | 8 +- parser/html/nsHtml5MetaScanner.cpp | 2 +- parser/html/nsHtml5MetaScanner.h | 2 +- parser/html/nsHtml5Portability.cpp | 12 +- parser/html/nsHtml5Portability.h | 10 +- parser/html/nsHtml5StackNode.cpp | 12 +- parser/html/nsHtml5StackNode.h | 16 +- parser/html/nsHtml5StateSnapshot.cpp | 2 +- parser/html/nsHtml5StateSnapshot.h | 2 +- parser/html/nsHtml5String.cpp | 2 +- parser/html/nsHtml5String.h | 18 +- parser/html/nsHtml5StringParser.cpp | 2 +- parser/html/nsHtml5StringParser.h | 2 +- parser/html/nsHtml5Tokenizer.cpp | 6 +- parser/html/nsHtml5Tokenizer.h | 6 +- parser/html/nsHtml5TreeBuilder.cpp | 64 ++--- parser/html/nsHtml5TreeBuilder.h | 58 ++--- parser/html/nsHtml5TreeBuilderCppSupplement.h | 52 ++--- parser/html/nsHtml5TreeBuilderHSupplement.h | 34 +-- parser/html/nsHtml5TreeOpExecutor.h | 2 +- parser/html/nsHtml5TreeOperation.cpp | 40 ++-- parser/html/nsHtml5TreeOperation.h | 24 +- parser/html/nsHtml5UTF16Buffer.cpp | 2 +- parser/html/nsHtml5UTF16Buffer.h | 2 +- parser/htmlparser/CParserContext.cpp | 2 +- parser/htmlparser/nsHTMLTags.cpp | 6 +- parser/htmlparser/nsHTMLTags.h | 8 +- parser/htmlparser/nsIParser.h | 2 +- parser/htmlparser/nsParser.cpp | 2 +- rdf/base/nsIRDFXMLSerializer.idl | 4 +- rdf/base/nsIRDFXMLSink.idl | 4 +- rdf/base/nsNameSpaceMap.cpp | 4 +- rdf/base/nsNameSpaceMap.h | 10 +- rdf/base/nsRDFContentSink.cpp | 28 +-- rdf/base/nsRDFService.cpp | 2 +- rdf/base/nsRDFXMLDataSource.cpp | 2 +- rdf/base/nsRDFXMLSerializer.cpp | 14 +- rdf/base/nsRDFXMLSerializer.h | 2 +- .../extensions/ExtensionPolicyService.h | 8 +- .../components/extensions/MatchPattern.cpp | 14 +- toolkit/components/extensions/MatchPattern.h | 24 +- .../extensions/WebExtensionPolicy.h | 6 +- .../extensions/webrequest/ChannelWrapper.cpp | 6 +- .../extensions/webrequest/ChannelWrapper.h | 8 +- .../extensions/webrequest/StreamFilter.h | 4 +- .../webrequest/StreamFilterParent.cpp | 2 +- .../webrequest/WebRequestService.cpp | 2 +- .../extensions/webrequest/WebRequestService.h | 4 +- toolkit/components/filepicker/nsFileView.cpp | 2 +- toolkit/components/find/nsFind.cpp | 2 +- .../satchel/nsFormFillController.cpp | 4 +- .../typeaheadfind/nsTypeAheadFind.cpp | 4 +- tools/jprof/split-profile.py | 2 +- uriloader/exthandler/nsMIMEInfoImpl.h | 2 +- widget/BasicEvents.h | 6 +- widget/MiscEvents.h | 8 +- widget/android/nsNativeThemeAndroid.cpp | 2 +- widget/android/nsNativeThemeAndroid.h | 2 +- widget/cocoa/nsChangeObserver.h | 6 +- widget/cocoa/nsMenuBarX.mm | 2 +- widget/cocoa/nsMenuGroupOwnerX.mm | 4 +- widget/cocoa/nsMenuItemX.mm | 2 +- widget/cocoa/nsMenuX.mm | 6 +- widget/cocoa/nsNativeThemeCocoa.h | 4 +- widget/cocoa/nsNativeThemeCocoa.mm | 4 +- widget/gtk/nsNativeThemeGTK.cpp | 4 +- widget/gtk/nsNativeThemeGTK.h | 4 +- widget/gtk/nsWindow.cpp | 2 +- widget/gtk/nsWindow.h | 2 +- widget/nsNativeTheme.cpp | 4 +- widget/nsNativeTheme.h | 6 +- widget/windows/KeyboardLayout.cpp | 2 +- widget/windows/nsNativeThemeWin.cpp | 2 +- widget/windows/nsNativeThemeWin.h | 4 +- xpcom/build/XPCOM.h | 2 +- xpcom/ds/moz.build | 2 +- xpcom/ds/{nsIAtom.h => nsAtom.h} | 18 +- xpcom/ds/nsAtomTable.cpp | 7 +- xpcom/ds/nsStaticAtom.h | 4 +- xpcom/io/nsAppFileLocationProvider.cpp | 2 +- xpcom/io/nsDirectoryService.cpp | 4 +- xpcom/io/nsDirectoryService.h | 4 +- xpcom/tests/gtest/TestAtoms.cpp | 30 +-- 971 files changed, 4230 insertions(+), 4235 deletions(-) rename xpcom/ds/{nsIAtom.h => nsAtom.h} (92%) diff --git a/.gdbinit b/.gdbinit index 08f1fc0f2011..7978d585e629 100644 --- a/.gdbinit +++ b/.gdbinit @@ -86,7 +86,7 @@ def ps end end -# Define a "pa" command to display the string value for an nsIAtom +# Define a "pa" command to display the string value for an nsAtom def pa set $atom = $arg0 if (sizeof(*((&*$atom)->mString)) == 2) diff --git a/.lldbinit b/.lldbinit index 652986f04007..1d090d0f2c63 100644 --- a/.lldbinit +++ b/.lldbinit @@ -22,7 +22,7 @@ settings set target.inline-breakpoint-strategy always settings set target.prefer-dynamic-value run-target # Show the string value in atoms. -type summary add nsIAtom --summary-string "${var.mString}" +type summary add nsAtom --summary-string "${var.mString}" # Show the value of text nodes. type summary add nsTextNode --summary-string "${var.mText}" diff --git a/accessible/base/ARIAMap.cpp b/accessible/base/ARIAMap.cpp index 32644c927d7d..6f9386483ff8 100644 --- a/accessible/base/ARIAMap.cpp +++ b/accessible/base/ARIAMap.cpp @@ -1230,7 +1230,7 @@ static const EStateRule sWAIUnivStateMap[] = { struct AttrCharacteristics { - nsIAtom** attributeName; + nsAtom** attributeName; const uint8_t characteristics; }; @@ -1361,7 +1361,7 @@ aria::UniversalStatesFor(mozilla::dom::Element* aElement) } uint8_t -aria::AttrCharacteristicsFor(nsIAtom* aAtom) +aria::AttrCharacteristicsFor(nsAtom* aAtom) { for (uint32_t i = 0; i < ArrayLength(gWAIUnivAttrMap); i++) if (*gWAIUnivAttrMap[i].attributeName == aAtom) @@ -1389,7 +1389,7 @@ AttrIterator::Next(nsAString& aAttrName, nsAString& aAttrValue) const nsAttrName* attr = mContent->GetAttrNameAt(mAttrIdx); mAttrIdx++; if (attr->NamespaceEquals(kNameSpaceID_None)) { - nsIAtom* attrAtom = attr->Atom(); + nsAtom* attrAtom = attr->Atom(); nsDependentAtomString attrStr(attrAtom); if (!StringBeginsWith(attrStr, NS_LITERAL_STRING("aria-"))) continue; // Not ARIA diff --git a/accessible/base/ARIAMap.h b/accessible/base/ARIAMap.h index 6c87f6075c94..7c8d946b7b85 100644 --- a/accessible/base/ARIAMap.h +++ b/accessible/base/ARIAMap.h @@ -12,7 +12,7 @@ #include "mozilla/a11y/AccTypes.h" #include "mozilla/a11y/Role.h" -#include "nsIAtom.h" +#include "nsAtom.h" #include "nsIContent.h" class nsINode; @@ -140,7 +140,7 @@ struct nsRoleMapEntry /** * Return true if matches to the given ARIA role. */ - bool Is(nsIAtom* aARIARole) const + bool Is(nsAtom* aARIARole) const { return *roleAtom == aARIARole; } /** @@ -156,7 +156,7 @@ struct nsRoleMapEntry { return nsDependentAtomString(*roleAtom); } // ARIA role: string representation such as "button" - nsIAtom** roleAtom; + nsAtom** roleAtom; // Role mapping rule: maps to enum Role mozilla::a11y::role role; @@ -274,7 +274,7 @@ uint64_t UniversalStatesFor(mozilla::dom::Element* aElement); * @return A bitflag representing the attribute characteristics * (see above for possible bit masks, prefixed "ATTR_") */ -uint8_t AttrCharacteristicsFor(nsIAtom* aAtom); +uint8_t AttrCharacteristicsFor(nsAtom* aAtom); /** * Return true if the element has defined aria-hidden. diff --git a/accessible/base/ARIAStateMap.cpp b/accessible/base/ARIAStateMap.cpp index 76992520c15c..9be395747d90 100644 --- a/accessible/base/ARIAStateMap.cpp +++ b/accessible/base/ARIAStateMap.cpp @@ -20,11 +20,11 @@ using namespace mozilla::a11y::aria; struct EnumTypeData { // ARIA attribute name. - nsIAtom* const mAttrName; + nsAtom* const mAttrName; // States if the attribute value is matched to the enum value. Used as // nsIContent::AttrValuesArray, last item must be nullptr. - nsIAtom* const* const mValues[4]; + nsAtom* const* const mValues[4]; // States applied if corresponding enum values are matched. const uint64_t mStates[3]; @@ -46,7 +46,7 @@ enum ETokenType */ struct TokenTypeData { - TokenTypeData(nsIAtom* aAttrName, uint32_t aType, + TokenTypeData(nsAtom* aAttrName, uint32_t aType, uint64_t aPermanentState, uint64_t aTrueState, uint64_t aFalseState = 0) : @@ -55,7 +55,7 @@ struct TokenTypeData { } // ARIA attribute name. - nsIAtom* const mAttrName; + nsAtom* const mAttrName; // Type. const uint32_t mType; diff --git a/accessible/base/AccEvent.h b/accessible/base/AccEvent.h index 6a4f46e1c67d..422f22176e6f 100644 --- a/accessible/base/AccEvent.h +++ b/accessible/base/AccEvent.h @@ -516,7 +516,7 @@ private: class AccObjectAttrChangedEvent: public AccEvent { public: - AccObjectAttrChangedEvent(Accessible* aAccessible, nsIAtom* aAttribute) : + AccObjectAttrChangedEvent(Accessible* aAccessible, nsAtom* aAttribute) : AccEvent(::nsIAccessibleEvent::EVENT_OBJECT_ATTRIBUTE_CHANGED, aAccessible), mAttribute(aAttribute) { } @@ -528,10 +528,10 @@ public: } // AccObjectAttrChangedEvent - nsIAtom* GetAttribute() const { return mAttribute; } + nsAtom* GetAttribute() const { return mAttribute; } private: - RefPtr mAttribute; + RefPtr mAttribute; virtual ~AccObjectAttrChangedEvent() { } }; diff --git a/accessible/base/AccIterator.cpp b/accessible/base/AccIterator.cpp index f6e890c5023c..81b28ba4ff16 100644 --- a/accessible/base/AccIterator.cpp +++ b/accessible/base/AccIterator.cpp @@ -76,12 +76,12 @@ AccIterator::IteratorState::IteratorState(Accessible* aParent, RelatedAccIterator:: RelatedAccIterator(DocAccessible* aDocument, nsIContent* aDependentContent, - nsIAtom* aRelAttr) : + nsAtom* aRelAttr) : mDocument(aDocument), mRelAttr(aRelAttr), mProviders(nullptr), mBindingParent(nullptr), mIndex(0) { mBindingParent = aDependentContent->GetBindingParent(); - nsIAtom* IDAttr = mBindingParent ? + nsAtom* IDAttr = mBindingParent ? nsGkAtoms::anonid : nsGkAtoms::id; nsAutoString id; @@ -254,7 +254,7 @@ XULDescriptionIterator::Next() IDRefsIterator:: IDRefsIterator(DocAccessible* aDoc, nsIContent* aContent, - nsIAtom* aIDRefsAttr) : + nsAtom* aIDRefsAttr) : mContent(aContent), mDoc(aDoc), mCurrIdx(0) { if (mContent->IsInUncomposedDoc()) diff --git a/accessible/base/AccIterator.h b/accessible/base/AccIterator.h index 362eb3a92b03..3f3d21990b8b 100644 --- a/accessible/base/AccIterator.h +++ b/accessible/base/AccIterator.h @@ -84,7 +84,7 @@ public: * pointed by */ RelatedAccIterator(DocAccessible* aDocument, nsIContent* aDependentContent, - nsIAtom* aRelAttr); + nsAtom* aRelAttr); virtual ~RelatedAccIterator() { } @@ -99,7 +99,7 @@ private: RelatedAccIterator& operator = (const RelatedAccIterator&); DocAccessible* mDocument; - nsIAtom* mRelAttr; + nsAtom* mRelAttr; DocAccessible::AttrRelProviderArray* mProviders; nsIContent* mBindingParent; uint32_t mIndex; @@ -219,7 +219,7 @@ class IDRefsIterator : public AccIterable { public: IDRefsIterator(DocAccessible* aDoc, nsIContent* aContent, - nsIAtom* aIDRefsAttr); + nsAtom* aIDRefsAttr); virtual ~IDRefsIterator() { } /** diff --git a/accessible/base/Logging.cpp b/accessible/base/Logging.cpp index 601d03ade93e..e827b3345119 100644 --- a/accessible/base/Logging.cpp +++ b/accessible/base/Logging.cpp @@ -853,7 +853,7 @@ logging::Node(const char* aDescr, nsINode* aNode) nsAutoCString tag; elm->NodeInfo()->NameAtom()->ToUTF8String(tag); - nsIAtom* idAtom = elm->GetID(); + nsAtom* idAtom = elm->GetID(); nsAutoCString id; if (idAtom) idAtom->ToUTF8String(id); @@ -919,7 +919,7 @@ logging::AccessibleInfo(const char* aDescr, Accessible* aAccessible) nsAutoCString tag; el->NodeInfo()->NameAtom()->ToUTF8String(tag); - nsIAtom* idAtom = el->GetID(); + nsAtom* idAtom = el->GetID(); nsAutoCString id; if (idAtom) { idAtom->ToUTF8String(id); diff --git a/accessible/base/nsAccUtils.cpp b/accessible/base/nsAccUtils.cpp index 54241d14a3d3..60df794fc787 100644 --- a/accessible/base/nsAccUtils.cpp +++ b/accessible/base/nsAccUtils.cpp @@ -25,7 +25,7 @@ using namespace mozilla::a11y; void nsAccUtils::GetAccAttr(nsIPersistentProperties *aAttributes, - nsIAtom *aAttrName, nsAString& aAttrValue) + nsAtom *aAttrName, nsAString& aAttrValue) { aAttrValue.Truncate(); @@ -34,7 +34,7 @@ nsAccUtils::GetAccAttr(nsIPersistentProperties *aAttributes, void nsAccUtils::SetAccAttr(nsIPersistentProperties *aAttributes, - nsIAtom *aAttrName, const nsAString& aAttrValue) + nsAtom *aAttrName, const nsAString& aAttrValue) { nsAutoString oldValue; aAttributes->SetStringProperty(nsAtomCString(aAttrName), aAttrValue, oldValue); @@ -42,7 +42,7 @@ nsAccUtils::SetAccAttr(nsIPersistentProperties *aAttributes, void nsAccUtils::SetAccAttr(nsIPersistentProperties *aAttributes, - nsIAtom* aAttrName, nsIAtom* aAttrValue) + nsAtom* aAttrName, nsAtom* aAttrValue) { nsAutoString oldValue; aAttributes->SetStringProperty(nsAtomCString(aAttrName), @@ -187,7 +187,7 @@ nsAccUtils::SetLiveContainerAttributes(nsIPersistentProperties *aAttributes, } bool -nsAccUtils::HasDefinedARIAToken(nsIContent *aContent, nsIAtom *aAtom) +nsAccUtils::HasDefinedARIAToken(nsIContent *aContent, nsAtom *aAtom) { NS_ASSERTION(aContent, "aContent is null in call to HasDefinedARIAToken!"); @@ -201,8 +201,8 @@ nsAccUtils::HasDefinedARIAToken(nsIContent *aContent, nsIAtom *aAtom) return true; } -nsIAtom* -nsAccUtils::GetARIAToken(dom::Element* aElement, nsIAtom* aAttr) +nsAtom* +nsAccUtils::GetARIAToken(dom::Element* aElement, nsAtom* aAttr) { if (!HasDefinedARIAToken(aElement, aAttr)) return nsGkAtoms::_empty; diff --git a/accessible/base/nsAccUtils.h b/accessible/base/nsAccUtils.h index 25758fbcd393..0f28a10e80eb 100644 --- a/accessible/base/nsAccUtils.h +++ b/accessible/base/nsAccUtils.h @@ -36,7 +36,7 @@ public: * @param aAttrValue - value of attribute */ static void GetAccAttr(nsIPersistentProperties *aAttributes, - nsIAtom *aAttrName, + nsAtom *aAttrName, nsAString& aAttrValue); /** @@ -47,12 +47,12 @@ public: * @param aAttrValue - new value of attribute */ static void SetAccAttr(nsIPersistentProperties *aAttributes, - nsIAtom *aAttrName, + nsAtom *aAttrName, const nsAString& aAttrValue); static void SetAccAttr(nsIPersistentProperties *aAttributes, - nsIAtom* aAttrName, - nsIAtom* aAttrValue); + nsAtom* aAttrName, + nsAtom* aAttrValue); /** * Set group attributes ('level', 'setsize', 'posinset'). @@ -95,12 +95,12 @@ public: * * Return true if the ARIA property is defined, otherwise false */ - static bool HasDefinedARIAToken(nsIContent *aContent, nsIAtom *aAtom); + static bool HasDefinedARIAToken(nsIContent *aContent, nsAtom *aAtom); /** * Return atomic value of ARIA attribute of boolean or NMTOKEN type. */ - static nsIAtom* GetARIAToken(mozilla::dom::Element* aElement, nsIAtom* aAttr); + static nsAtom* GetARIAToken(mozilla::dom::Element* aElement, nsAtom* aAttr); /** * Return document accessible for the given DOM node. diff --git a/accessible/base/nsAccessibilityService.cpp b/accessible/base/nsAccessibilityService.cpp index 7c7124c3f51d..3ed4b3d5b5e2 100644 --- a/accessible/base/nsAccessibilityService.cpp +++ b/accessible/base/nsAccessibilityService.cpp @@ -112,7 +112,7 @@ MustBeAccessible(nsIContent* aContent, DocAccessible* aDocument) for (uint32_t attrIdx = 0; attrIdx < attrCount; attrIdx++) { const nsAttrName* attr = aContent->GetAttrNameAt(attrIdx); if (attr->NamespaceEquals(kNameSpaceID_None)) { - nsIAtom* attrAtom = attr->Atom(); + nsAtom* attrAtom = attr->Atom(); nsDependentAtomString attrStr(attrAtom); if (!StringBeginsWith(attrStr, NS_LITERAL_STRING("aria-"))) continue; // not ARIA diff --git a/accessible/base/nsAccessibilityService.h b/accessible/base/nsAccessibilityService.h index 13e23025624e..6c7ee0d521d7 100644 --- a/accessible/base/nsAccessibilityService.h +++ b/accessible/base/nsAccessibilityService.h @@ -53,15 +53,15 @@ xpcAccessibleApplication* XPCApplicationAcc(); typedef Accessible* (New_Accessible)(nsIContent* aContent, Accessible* aContext); struct MarkupAttrInfo { - nsIAtom** name; - nsIAtom** value; + nsAtom** name; + nsAtom** value; - nsIAtom** DOMAttrName; - nsIAtom** DOMAttrValue; + nsAtom** DOMAttrName; + nsAtom** DOMAttrValue; }; struct MarkupMapInfo { - nsIAtom** tag; + nsAtom** tag; New_Accessible* new_func; a11y::role role; MarkupAttrInfo attrs[4]; @@ -310,7 +310,7 @@ private: */ static uint32_t gConsumers; - nsDataHashtable, const mozilla::a11y::MarkupMapInfo*> mMarkupMaps; + nsDataHashtable, const mozilla::a11y::MarkupMapInfo*> mMarkupMaps; friend nsAccessibilityService* GetAccService(); friend nsAccessibilityService* GetOrCreateAccService(uint32_t); diff --git a/accessible/base/nsCoreUtils.cpp b/accessible/base/nsCoreUtils.cpp index f8ff13d33c1c..b23c94d65667 100644 --- a/accessible/base/nsCoreUtils.cpp +++ b/accessible/base/nsCoreUtils.cpp @@ -459,7 +459,7 @@ nsCoreUtils::GetID(nsIContent *aContent, nsAString& aID) } bool -nsCoreUtils::GetUIntAttr(nsIContent *aContent, nsIAtom *aAttr, int32_t *aUInt) +nsCoreUtils::GetUIntAttr(nsIContent *aContent, nsAtom *aAttr, int32_t *aUInt) { nsAutoString value; aContent->GetAttr(kNameSpaceID_None, aAttr, value); diff --git a/accessible/base/nsCoreUtils.h b/accessible/base/nsCoreUtils.h index 74c45eeb5a7b..3009e1ff76da 100644 --- a/accessible/base/nsCoreUtils.h +++ b/accessible/base/nsCoreUtils.h @@ -220,7 +220,7 @@ public: * Convert attribute value of the given node to positive integer. If no * attribute or wrong value then false is returned. */ - static bool GetUIntAttr(nsIContent *aContent, nsIAtom *aAttr, + static bool GetUIntAttr(nsIContent *aContent, nsAtom *aAttr, int32_t* aUInt); /** diff --git a/accessible/base/nsTextEquivUtils.cpp b/accessible/base/nsTextEquivUtils.cpp index 4a0ef9156661..bd783eb07bbe 100644 --- a/accessible/base/nsTextEquivUtils.cpp +++ b/accessible/base/nsTextEquivUtils.cpp @@ -52,7 +52,7 @@ nsTextEquivUtils::GetNameFromSubtree(Accessible* aAccessible, nsresult nsTextEquivUtils::GetTextEquivFromIDRefs(Accessible* aAccessible, - nsIAtom *aIDRefsAttr, + nsAtom *aIDRefsAttr, nsAString& aTextEquiv) { aTextEquiv.Truncate(); diff --git a/accessible/base/nsTextEquivUtils.h b/accessible/base/nsTextEquivUtils.h index 3f42ee67cead..26e80d04cd2e 100644 --- a/accessible/base/nsTextEquivUtils.h +++ b/accessible/base/nsTextEquivUtils.h @@ -86,7 +86,7 @@ public: * @param aTextEquiv [out] result text equivalent */ static nsresult GetTextEquivFromIDRefs(Accessible* aAccessible, - nsIAtom *aIDRefsAttr, + nsAtom *aIDRefsAttr, nsAString& aTextEquiv); /** diff --git a/accessible/generic/Accessible-inl.h b/accessible/generic/Accessible-inl.h index 21be548c07d0..e8fb2ec968b9 100644 --- a/accessible/generic/Accessible-inl.h +++ b/accessible/generic/Accessible-inl.h @@ -35,7 +35,7 @@ Accessible::HasARIARole() const } inline bool -Accessible::IsARIARole(nsIAtom* aARIARole) const +Accessible::IsARIARole(nsAtom* aARIARole) const { const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); return roleMapEntry && roleMapEntry->Is(aARIARole); diff --git a/accessible/generic/Accessible.cpp b/accessible/generic/Accessible.cpp index 1db01178724e..694ae7d07af5 100644 --- a/accessible/generic/Accessible.cpp +++ b/accessible/generic/Accessible.cpp @@ -61,7 +61,7 @@ #include "nsUnicharUtils.h" #include "nsReadableUtils.h" #include "prdtoa.h" -#include "nsIAtom.h" +#include "nsAtom.h" #include "nsIURI.h" #include "nsArrayUtils.h" #include "nsIMutableArray.h" @@ -933,7 +933,7 @@ Accessible::Attributes() return attributes.forget(); // 'xml-roles' attribute for landmark. - nsIAtom* landmark = LandmarkRole(); + nsAtom* landmark = LandmarkRole(); if (landmark) { nsAccUtils::SetAccAttr(attributes, nsGkAtoms::xmlroles, landmark); @@ -1483,7 +1483,7 @@ Accessible::ARIATransformRole(role aRole) return aRole; } -nsIAtom* +nsAtom* Accessible::LandmarkRole() const { const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); @@ -2564,7 +2564,7 @@ Accessible::CurrentItem() void Accessible::SetCurrentItem(Accessible* aItem) { - nsIAtom* id = aItem->GetContent()->GetID(); + nsAtom* id = aItem->GetContent()->GetID(); if (id) { nsAutoString idStr; id->ToString(idStr); @@ -2647,7 +2647,7 @@ Accessible::GetSiblingAtOffset(int32_t aOffset, nsresult* aError) const } double -Accessible::AttrNumericValue(nsIAtom* aAttr) const +Accessible::AttrNumericValue(nsAtom* aAttr) const { const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); if (!roleMapEntry || roleMapEntry->valueRule == eNoValue) diff --git a/accessible/generic/Accessible.h b/accessible/generic/Accessible.h index 2b77d865e8d5..b37a661e338f 100644 --- a/accessible/generic/Accessible.h +++ b/accessible/generic/Accessible.h @@ -24,7 +24,7 @@ struct nsRoleMapEntry; struct nsRect; class nsIFrame; -class nsIAtom; +class nsAtom; class nsIPersistentProperties; namespace mozilla { @@ -232,7 +232,7 @@ public: * Return true if ARIA role is specified on the element. */ bool HasARIARole() const; - bool IsARIARole(nsIAtom* aARIARole) const; + bool IsARIARole(nsAtom* aARIARole) const; bool HasStrongARIARole() const; /** @@ -249,7 +249,7 @@ public: /** * Return a landmark role if applied. */ - virtual nsIAtom* LandmarkRole() const; + virtual nsAtom* LandmarkRole() const; /** * Returns enumerated accessible role from native markup (see constants in @@ -1109,7 +1109,7 @@ protected: * @param aARIAProperty [in] the ARIA property we're using * @return a numeric value */ - double AttrNumericValue(nsIAtom* aARIAAttr) const; + double AttrNumericValue(nsAtom* aARIAAttr) const; /** * Return the action rule based on ARIA enum constants EActionRule diff --git a/accessible/generic/DocAccessible.cpp b/accessible/generic/DocAccessible.cpp index c785d8d66d71..d9562b0ff144 100644 --- a/accessible/generic/DocAccessible.cpp +++ b/accessible/generic/DocAccessible.cpp @@ -62,7 +62,7 @@ using namespace mozilla::a11y; //////////////////////////////////////////////////////////////////////////////// // Static member initialization -static nsIAtom** kRelationAttrs[] = +static nsAtom** kRelationAttrs[] = { &nsGkAtoms::aria_labelledby, &nsGkAtoms::aria_describedby, @@ -715,7 +715,7 @@ void DocAccessible::AttributeWillChange(nsIDocument* aDocument, dom::Element* aElement, int32_t aNameSpaceID, - nsIAtom* aAttribute, int32_t aModType, + nsAtom* aAttribute, int32_t aModType, const nsAttrValue* aNewValue) { Accessible* accessible = GetAccessible(aElement); @@ -767,7 +767,7 @@ DocAccessible::NativeAnonymousChildListChange(nsIDocument* aDocument, void DocAccessible::AttributeChanged(nsIDocument* aDocument, dom::Element* aElement, - int32_t aNameSpaceID, nsIAtom* aAttribute, + int32_t aNameSpaceID, nsAtom* aAttribute, int32_t aModType, const nsAttrValue* aOldValue) { @@ -813,7 +813,7 @@ DocAccessible::AttributeChanged(nsIDocument* aDocument, // DocAccessible protected member void DocAccessible::AttributeChangedImpl(Accessible* aAccessible, - int32_t aNameSpaceID, nsIAtom* aAttribute) + int32_t aNameSpaceID, nsAtom* aAttribute) { // Fire accessible event after short timer, because we need to wait for // DOM attribute & resulting layout to actually change. Otherwise, @@ -952,7 +952,7 @@ DocAccessible::AttributeChangedImpl(Accessible* aAccessible, // DocAccessible protected member void -DocAccessible::ARIAAttributeChanged(Accessible* aAccessible, nsIAtom* aAttribute) +DocAccessible::ARIAAttributeChanged(Accessible* aAccessible, nsAtom* aAttribute) { // Note: For universal/global ARIA states and properties we don't care if // there is an ARIA role present or not. @@ -1580,14 +1580,14 @@ DocAccessible::ProcessLoad() } void -DocAccessible::AddDependentIDsFor(Accessible* aRelProvider, nsIAtom* aRelAttr) +DocAccessible::AddDependentIDsFor(Accessible* aRelProvider, nsAtom* aRelAttr) { dom::Element* relProviderEl = aRelProvider->Elm(); if (!relProviderEl) return; for (uint32_t idx = 0; idx < kRelationAttrsLen; idx++) { - nsIAtom* relAttr = *kRelationAttrs[idx]; + nsAtom* relAttr = *kRelationAttrs[idx]; if (aRelAttr && aRelAttr != relAttr) continue; @@ -1652,14 +1652,14 @@ DocAccessible::AddDependentIDsFor(Accessible* aRelProvider, nsIAtom* aRelAttr) void DocAccessible::RemoveDependentIDsFor(Accessible* aRelProvider, - nsIAtom* aRelAttr) + nsAtom* aRelAttr) { dom::Element* relProviderElm = aRelProvider->Elm(); if (!relProviderElm) return; for (uint32_t idx = 0; idx < kRelationAttrsLen; idx++) { - nsIAtom* relAttr = *kRelationAttrs[idx]; + nsAtom* relAttr = *kRelationAttrs[idx]; if (aRelAttr && aRelAttr != *kRelationAttrs[idx]) continue; @@ -1693,7 +1693,7 @@ DocAccessible::RemoveDependentIDsFor(Accessible* aRelProvider, bool DocAccessible::UpdateAccessibleOnAttrChange(dom::Element* aElement, - nsIAtom* aAttribute) + nsAtom* aAttribute) { if (aAttribute == nsGkAtoms::role) { // It is common for js libraries to set the role on the body element after diff --git a/accessible/generic/DocAccessible.h b/accessible/generic/DocAccessible.h index c336ed3a9ced..26f3b0b51d46 100644 --- a/accessible/generic/DocAccessible.h +++ b/accessible/generic/DocAccessible.h @@ -448,7 +448,7 @@ protected: * @param aRelAttr [in, optional] relation attribute */ void AddDependentIDsFor(Accessible* aRelProvider, - nsIAtom* aRelAttr = nullptr); + nsAtom* aRelAttr = nullptr); /** * Remove dependent IDs pointed by accessible element by relation attribute @@ -459,7 +459,7 @@ protected: * @param aRelAttr [in, optional] relation attribute */ void RemoveDependentIDsFor(Accessible* aRelProvider, - nsIAtom* aRelAttr = nullptr); + nsAtom* aRelAttr = nullptr); /** * Update or recreate an accessible depending on a changed attribute. @@ -469,7 +469,7 @@ protected: * @return true if an action was taken on the attribute change */ bool UpdateAccessibleOnAttrChange(mozilla::dom::Element* aElement, - nsIAtom* aAttribute); + nsAtom* aAttribute); /** * Fire accessible events when attribute is changed. @@ -479,7 +479,7 @@ protected: * @param aAttribute [in] changed attribute */ void AttributeChangedImpl(Accessible* aAccessible, - int32_t aNameSpaceID, nsIAtom* aAttribute); + int32_t aNameSpaceID, nsAtom* aAttribute); /** * Fire accessible events when ARIA attribute is changed. @@ -487,7 +487,7 @@ protected: * @param aAccessible [in] accesislbe the DOM attribute is changed for * @param aAttribute [in] changed attribute */ - void ARIAAttributeChanged(Accessible* aAccessible, nsIAtom* aAttribute); + void ARIAAttributeChanged(Accessible* aAccessible, nsAtom* aAttribute); /** * Process ARIA active-descendant attribute change. @@ -626,7 +626,7 @@ protected: */ union { // ARIA attribute value - nsIAtom* mARIAAttrOldValue; + nsAtom* mARIAAttrOldValue; // True if the accessible state bit was on bool mStateBitWasOn; @@ -645,10 +645,10 @@ protected: class AttrRelProvider { public: - AttrRelProvider(nsIAtom* aRelAttr, nsIContent* aContent) : + AttrRelProvider(nsAtom* aRelAttr, nsIContent* aContent) : mRelAttr(aRelAttr), mContent(aContent) { } - nsIAtom* mRelAttr; + nsAtom* mRelAttr; nsCOMPtr mContent; private: diff --git a/accessible/generic/HyperTextAccessible.cpp b/accessible/generic/HyperTextAccessible.cpp index 5a819b4737a7..95b04a7a601c 100644 --- a/accessible/generic/HyperTextAccessible.cpp +++ b/accessible/generic/HyperTextAccessible.cpp @@ -1130,7 +1130,7 @@ HyperTextAccessible::NativeAttributes() return attributes.forget(); } -nsIAtom* +nsAtom* HyperTextAccessible::LandmarkRole() const { if (!HasOwnContent()) diff --git a/accessible/generic/HyperTextAccessible.h b/accessible/generic/HyperTextAccessible.h index 251b1deed068..6b0e66060f60 100644 --- a/accessible/generic/HyperTextAccessible.h +++ b/accessible/generic/HyperTextAccessible.h @@ -54,7 +54,7 @@ public: NS_DECL_ISUPPORTS_INHERITED // Accessible - virtual nsIAtom* LandmarkRole() const override; + virtual nsAtom* LandmarkRole() const override; virtual int32_t GetLevelInternal() override; virtual already_AddRefed NativeAttributes() override; virtual mozilla::a11y::role NativeRole() override; diff --git a/accessible/html/HTMLElementAccessibles.cpp b/accessible/html/HTMLElementAccessibles.cpp index 614c61228f86..4acd272765a3 100644 --- a/accessible/html/HTMLElementAccessibles.cpp +++ b/accessible/html/HTMLElementAccessibles.cpp @@ -241,7 +241,7 @@ HTMLHeaderOrFooterAccessible::NativeRole() return roles::SECTION; } -nsIAtom* +nsAtom* HTMLHeaderOrFooterAccessible::LandmarkRole() const { if (!HasOwnContent()) diff --git a/accessible/html/HTMLElementAccessibles.h b/accessible/html/HTMLElementAccessibles.h index d8e80f3c9740..56d711046711 100644 --- a/accessible/html/HTMLElementAccessibles.h +++ b/accessible/html/HTMLElementAccessibles.h @@ -127,7 +127,7 @@ public: NS_DECL_ISUPPORTS_INHERITED // Accessible - virtual nsIAtom* LandmarkRole() const override; + virtual nsAtom* LandmarkRole() const override; virtual a11y::role NativeRole() override; protected: diff --git a/accessible/ipc/ProxyAccessibleShared.h b/accessible/ipc/ProxyAccessibleShared.h index e940d72ed358..538a5ea92288 100644 --- a/accessible/ipc/ProxyAccessibleShared.h +++ b/accessible/ipc/ProxyAccessibleShared.h @@ -60,9 +60,9 @@ void Relations(nsTArray* aTypes, bool IsSearchbox() const; -nsIAtom* LandmarkRole() const; +nsAtom* LandmarkRole() const; -nsIAtom* ARIARoleAtom() const; +nsAtom* ARIARoleAtom() const; int32_t GetLevelInternal(); void ScrollTo(uint32_t aScrollType); diff --git a/accessible/ipc/other/DocAccessibleChild.cpp b/accessible/ipc/other/DocAccessibleChild.cpp index e37f99a053b6..db000d102f6f 100644 --- a/accessible/ipc/other/DocAccessibleChild.cpp +++ b/accessible/ipc/other/DocAccessibleChild.cpp @@ -277,7 +277,7 @@ DocAccessibleChild::RecvLandmarkRole(const uint64_t& aID, nsString* aLandmark) return IPC_OK(); } - if (nsIAtom* roleAtom = acc->LandmarkRole()) { + if (nsAtom* roleAtom = acc->LandmarkRole()) { roleAtom->ToString(*aLandmark); } @@ -293,7 +293,7 @@ DocAccessibleChild::RecvARIARoleAtom(const uint64_t& aID, nsString* aRole) } if (const nsRoleMapEntry* roleMap = acc->ARIARoleMap()) { - if (nsIAtom* roleAtom = *(roleMap->roleAtom)) { + if (nsAtom* roleAtom = *(roleMap->roleAtom)) { roleAtom->ToString(*aRole); } } @@ -1996,7 +1996,7 @@ DocAccessibleChild::RecvDOMNodeID(const uint64_t& aID, nsString* aDOMNodeID) return IPC_OK(); } - nsIAtom* id = content->GetID(); + nsAtom* id = content->GetID(); if (id) { id->ToString(*aDOMNodeID); } diff --git a/accessible/ipc/other/ProxyAccessible.cpp b/accessible/ipc/other/ProxyAccessible.cpp index 9249b999096e..6bc36f30313f 100644 --- a/accessible/ipc/other/ProxyAccessible.cpp +++ b/accessible/ipc/other/ProxyAccessible.cpp @@ -119,7 +119,7 @@ ProxyAccessible::IsSearchbox() const return retVal; } -nsIAtom* +nsAtom* ProxyAccessible::LandmarkRole() const { nsString landmark; @@ -127,7 +127,7 @@ ProxyAccessible::LandmarkRole() const return NS_GetStaticAtom(landmark); } -nsIAtom* +nsAtom* ProxyAccessible::ARIARoleAtom() const { nsString role; diff --git a/accessible/mac/mozAccessible.mm b/accessible/mac/mozAccessible.mm index 2a8dbb988d94..183ef853dca7 100644 --- a/accessible/mac/mozAccessible.mm +++ b/accessible/mac/mozAccessible.mm @@ -733,7 +733,7 @@ ConvertToNSArray(nsTArray& aArray) ProxyAccessible* proxy = [self getProxyAccessible]; // Deal with landmarks first - nsIAtom* landmark = nullptr; + nsAtom* landmark = nullptr; if (accWrap) landmark = accWrap->LandmarkRole(); else if (proxy) @@ -770,7 +770,7 @@ ConvertToNSArray(nsTArray& aArray) return @"AXLandmarkRegion"; // Now, deal with widget roles - nsIAtom* roleAtom = nullptr; + nsAtom* roleAtom = nullptr; if (accWrap && accWrap->HasARIARole()) { const nsRoleMapEntry* roleMap = accWrap->ARIARoleMap(); roleAtom = *roleMap->roleAtom; diff --git a/accessible/windows/msaa/GeckoCustom.cpp b/accessible/windows/msaa/GeckoCustom.cpp index 6a61f73fd607..f3d1449318f0 100644 --- a/accessible/windows/msaa/GeckoCustom.cpp +++ b/accessible/windows/msaa/GeckoCustom.cpp @@ -28,7 +28,7 @@ GeckoCustom::get_DOMNodeID(BSTR* aID) return S_OK; } - nsIAtom* id = content->GetID(); + nsAtom* id = content->GetID(); if (id) { nsAutoString idStr; id->ToString(idStr); diff --git a/accessible/xul/XULSliderAccessible.cpp b/accessible/xul/XULSliderAccessible.cpp index 476cb17ebf52..eb8032105b0b 100644 --- a/accessible/xul/XULSliderAccessible.cpp +++ b/accessible/xul/XULSliderAccessible.cpp @@ -143,7 +143,7 @@ XULSliderAccessible::GetSliderElement() const } nsresult -XULSliderAccessible::GetSliderAttr(nsIAtom* aName, nsAString& aValue) const +XULSliderAccessible::GetSliderAttr(nsAtom* aName, nsAString& aValue) const { aValue.Truncate(); @@ -158,7 +158,7 @@ XULSliderAccessible::GetSliderAttr(nsIAtom* aName, nsAString& aValue) const } nsresult -XULSliderAccessible::SetSliderAttr(nsIAtom* aName, const nsAString& aValue) +XULSliderAccessible::SetSliderAttr(nsAtom* aName, const nsAString& aValue) { if (IsDefunct()) return NS_ERROR_FAILURE; @@ -171,7 +171,7 @@ XULSliderAccessible::SetSliderAttr(nsIAtom* aName, const nsAString& aValue) } double -XULSliderAccessible::GetSliderAttr(nsIAtom* aName) const +XULSliderAccessible::GetSliderAttr(nsAtom* aName) const { nsAutoString attrValue; nsresult rv = GetSliderAttr(aName, attrValue); @@ -184,7 +184,7 @@ XULSliderAccessible::GetSliderAttr(nsIAtom* aName) const } bool -XULSliderAccessible::SetSliderAttr(nsIAtom* aName, double aValue) +XULSliderAccessible::SetSliderAttr(nsAtom* aName, double aValue) { nsAutoString value; value.AppendFloat(aValue); diff --git a/accessible/xul/XULSliderAccessible.h b/accessible/xul/XULSliderAccessible.h index 72c914c2670d..2559998f53a1 100644 --- a/accessible/xul/XULSliderAccessible.h +++ b/accessible/xul/XULSliderAccessible.h @@ -45,11 +45,11 @@ protected: */ nsIContent* GetSliderElement() const; - nsresult GetSliderAttr(nsIAtom *aName, nsAString& aValue) const; - nsresult SetSliderAttr(nsIAtom *aName, const nsAString& aValue); + nsresult GetSliderAttr(nsAtom *aName, nsAString& aValue) const; + nsresult SetSliderAttr(nsAtom *aName, const nsAString& aValue); - double GetSliderAttr(nsIAtom *aName) const; - bool SetSliderAttr(nsIAtom *aName, double aValue); + double GetSliderAttr(nsAtom *aName) const; + bool SetSliderAttr(nsAtom *aName, double aValue); private: mutable nsCOMPtr mSliderNode; diff --git a/caps/BasePrincipal.cpp b/caps/BasePrincipal.cpp index 17b56b5f4261..9dee6f5f4aea 100644 --- a/caps/BasePrincipal.cpp +++ b/caps/BasePrincipal.cpp @@ -349,7 +349,7 @@ BasePrincipal::AddonPolicy() } bool -BasePrincipal::AddonHasPermission(const nsIAtom* aPerm) +BasePrincipal::AddonHasPermission(const nsAtom* aPerm) { if (auto policy = AddonPolicy()) { return policy->HasPermission(aPerm); diff --git a/caps/BasePrincipal.h b/caps/BasePrincipal.h index f31bfc78a42e..5bcd223010e0 100644 --- a/caps/BasePrincipal.h +++ b/caps/BasePrincipal.h @@ -12,7 +12,7 @@ #include "mozilla/Attributes.h" #include "mozilla/OriginAttributes.h" -class nsIAtom; +class nsAtom; class nsIContentSecurityPolicy; class nsIObjectOutputStream; class nsIObjectInputStream; @@ -86,7 +86,7 @@ public: NS_IMETHOD GetUserContextId(uint32_t* aUserContextId) final; NS_IMETHOD GetPrivateBrowsingId(uint32_t* aPrivateBrowsingId) final; - virtual bool AddonHasPermission(const nsIAtom* aPerm); + virtual bool AddonHasPermission(const nsAtom* aPerm); virtual bool IsCodebasePrincipal() const { return false; }; @@ -158,8 +158,8 @@ private: CreateCodebasePrincipal(nsIURI* aURI, const OriginAttributes& aAttrs, const nsACString& aOriginNoSuffix); - RefPtr mOriginNoSuffix; - RefPtr mOriginSuffix; + RefPtr mOriginNoSuffix; + RefPtr mOriginSuffix; OriginAttributes mOriginAttributes; PrincipalKind mKind; diff --git a/caps/ExpandedPrincipal.cpp b/caps/ExpandedPrincipal.cpp index e123662a5ccd..fe7c92c519e4 100644 --- a/caps/ExpandedPrincipal.cpp +++ b/caps/ExpandedPrincipal.cpp @@ -172,7 +172,7 @@ ExpandedPrincipal::GetAddonId(nsAString& aAddonId) }; bool -ExpandedPrincipal::AddonHasPermission(const nsIAtom* aPerm) +ExpandedPrincipal::AddonHasPermission(const nsAtom* aPerm) { for (size_t i = 0; i < mPrincipals.Length(); ++i) { if (BasePrincipal::Cast(mPrincipals[i])->AddonHasPermission(aPerm)) { diff --git a/caps/ExpandedPrincipal.h b/caps/ExpandedPrincipal.h index 831340100b66..c2b69be35297 100644 --- a/caps/ExpandedPrincipal.h +++ b/caps/ExpandedPrincipal.h @@ -34,7 +34,7 @@ public: NS_IMETHOD SetDomain(nsIURI* aDomain) override; NS_IMETHOD GetBaseDomain(nsACString& aBaseDomain) override; NS_IMETHOD GetAddonId(nsAString& aAddonId) override; - virtual bool AddonHasPermission(const nsIAtom* aPerm) override; + virtual bool AddonHasPermission(const nsAtom* aPerm) override; virtual nsresult GetScriptLocation(nsACString &aStr) override; protected: diff --git a/docshell/base/nsDocShell.cpp b/docshell/base/nsDocShell.cpp index 430bb912b96f..c7ba6e0fdb2b 100644 --- a/docshell/base/nsDocShell.cpp +++ b/docshell/base/nsDocShell.cpp @@ -362,7 +362,7 @@ ForEachPing(nsIContent* aContent, ForEachPingCallback aCallback, void* aClosure) return; } - RefPtr pingAtom = NS_Atomize("ping"); + RefPtr pingAtom = NS_Atomize("ping"); if (!pingAtom) { return; } diff --git a/docshell/base/nsDocShellTreeOwner.cpp b/docshell/base/nsDocShellTreeOwner.cpp index ae78ee91d358..6b85d7bd1650 100644 --- a/docshell/base/nsDocShellTreeOwner.cpp +++ b/docshell/base/nsDocShellTreeOwner.cpp @@ -16,7 +16,7 @@ #include "nsIServiceManager.h" #include "nsComponentManagerUtils.h" #include "nsString.h" -#include "nsIAtom.h" +#include "nsAtom.h" #include "nsReadableUtils.h" #include "nsUnicharUtils.h" #include "nsISimpleEnumerator.h" diff --git a/docshell/shistory/nsSHEntryShared.cpp b/docshell/shistory/nsSHEntryShared.cpp index c33bd51ff4d7..73ac140ea10d 100644 --- a/docshell/shistory/nsSHEntryShared.cpp +++ b/docshell/shistory/nsSHEntryShared.cpp @@ -274,7 +274,7 @@ void nsSHEntryShared::AttributeWillChange(nsIDocument* aDocument, dom::Element* aContent, int32_t aNameSpaceID, - nsIAtom* aAttribute, + nsAtom* aAttribute, int32_t aModType, const nsAttrValue* aNewValue) { @@ -291,7 +291,7 @@ void nsSHEntryShared::AttributeChanged(nsIDocument* aDocument, dom::Element* aElement, int32_t aNameSpaceID, - nsIAtom* aAttribute, + nsAtom* aAttribute, int32_t aModType, const nsAttrValue* aOldValue) { diff --git a/dom/animation/AnimationUtils.cpp b/dom/animation/AnimationUtils.cpp index 98cbccd21148..2450f0bb7c13 100644 --- a/dom/animation/AnimationUtils.cpp +++ b/dom/animation/AnimationUtils.cpp @@ -7,7 +7,7 @@ #include "AnimationUtils.h" #include "nsDebug.h" -#include "nsIAtom.h" +#include "nsAtom.h" #include "nsIContent.h" #include "nsIDocument.h" #include "nsGlobalWindow.h" @@ -27,7 +27,7 @@ AnimationUtils::LogAsyncAnimationFailure(nsCString& aMessage, aMessage.AppendLiteral(" ["); aMessage.Append(nsAtomCString(aContent->NodeInfo()->NameAtom())); - nsIAtom* id = aContent->GetID(); + nsAtom* id = aContent->GetID(); if (id) { aMessage.AppendLiteral(" with id '"); aMessage.Append(nsAtomCString(aContent->GetID())); diff --git a/dom/animation/CSSPseudoElement.cpp b/dom/animation/CSSPseudoElement.cpp index 903acb83b78e..fc782e081711 100644 --- a/dom/animation/CSSPseudoElement.cpp +++ b/dom/animation/CSSPseudoElement.cpp @@ -82,7 +82,7 @@ CSSPseudoElement::GetCSSPseudoElement(Element* aElement, return nullptr; } - nsIAtom* propName = CSSPseudoElement::GetCSSPseudoElementPropertyAtom(aType); + nsAtom* propName = CSSPseudoElement::GetCSSPseudoElementPropertyAtom(aType); RefPtr pseudo = static_cast(aElement->GetProperty(propName)); if (pseudo) { @@ -102,7 +102,7 @@ CSSPseudoElement::GetCSSPseudoElement(Element* aElement, return pseudo.forget(); } -/* static */ nsIAtom* +/* static */ nsAtom* CSSPseudoElement::GetCSSPseudoElementPropertyAtom(CSSPseudoElementType aType) { switch (aType) { diff --git a/dom/animation/CSSPseudoElement.h b/dom/animation/CSSPseudoElement.h index 00445cc60a73..19e917401e5d 100644 --- a/dom/animation/CSSPseudoElement.h +++ b/dom/animation/CSSPseudoElement.h @@ -76,7 +76,7 @@ private: // Only ::before and ::after are supported. CSSPseudoElement(Element* aElement, CSSPseudoElementType aType); - static nsIAtom* GetCSSPseudoElementPropertyAtom(CSSPseudoElementType aType); + static nsAtom* GetCSSPseudoElementPropertyAtom(CSSPseudoElementType aType); // mParentElement needs to be an owning reference since if script is holding // on to the pseudo-element, it needs to continue to be able to refer to diff --git a/dom/animation/EffectCompositor.cpp b/dom/animation/EffectCompositor.cpp index 4b89b29dfad5..f7828389c1b1 100644 --- a/dom/animation/EffectCompositor.cpp +++ b/dom/animation/EffectCompositor.cpp @@ -28,7 +28,7 @@ #include "nsCSSPseudoElements.h" #include "nsCSSPropertyIDSet.h" #include "nsCSSProps.h" -#include "nsIAtom.h" +#include "nsAtom.h" #include "nsIPresShell.h" #include "nsIPresShellInlines.h" #include "nsLayoutUtils.h" diff --git a/dom/animation/EffectCompositor.h b/dom/animation/EffectCompositor.h index 1d505cbc468f..9baef1a389d1 100644 --- a/dom/animation/EffectCompositor.h +++ b/dom/animation/EffectCompositor.h @@ -20,7 +20,7 @@ #include "nsTArray.h" class nsCSSPropertyIDSet; -class nsIAtom; +class nsAtom; class nsIFrame; class nsIStyleRule; class nsPresContext; diff --git a/dom/animation/EffectSet.cpp b/dom/animation/EffectSet.cpp index 4180ebbfcb4f..3e05f70142dd 100644 --- a/dom/animation/EffectSet.cpp +++ b/dom/animation/EffectSet.cpp @@ -16,7 +16,7 @@ namespace mozilla { /* static */ void -EffectSet::PropertyDtor(void* aObject, nsIAtom* aPropertyName, +EffectSet::PropertyDtor(void* aObject, nsAtom* aPropertyName, void* aPropertyValue, void* aData) { EffectSet* effectSet = static_cast(aPropertyValue); @@ -46,7 +46,7 @@ EffectSet::GetEffectSet(const dom::Element* aElement, return nullptr; } - nsIAtom* propName = GetEffectSetPropertyAtom(aPseudoType); + nsAtom* propName = GetEffectSetPropertyAtom(aPseudoType); return static_cast(aElement->GetProperty(propName)); } @@ -72,7 +72,7 @@ EffectSet::GetOrCreateEffectSet(dom::Element* aElement, return effectSet; } - nsIAtom* propName = GetEffectSetPropertyAtom(aPseudoType); + nsAtom* propName = GetEffectSetPropertyAtom(aPseudoType); effectSet = new EffectSet(); nsresult rv = aElement->SetProperty(propName, effectSet, @@ -94,7 +94,7 @@ EffectSet::GetOrCreateEffectSet(dom::Element* aElement, EffectSet::DestroyEffectSet(dom::Element* aElement, CSSPseudoElementType aPseudoType) { - nsIAtom* propName = GetEffectSetPropertyAtom(aPseudoType); + nsAtom* propName = GetEffectSetPropertyAtom(aPseudoType); EffectSet* effectSet = static_cast(aElement->GetProperty(propName)); if (!effectSet) { @@ -115,10 +115,10 @@ EffectSet::UpdateAnimationGeneration(nsPresContext* aPresContext) aPresContext->RestyleManager()->GetAnimationGeneration(); } -/* static */ nsIAtom** +/* static */ nsAtom** EffectSet::GetEffectSetPropertyAtoms() { - static nsIAtom* effectSetPropertyAtoms[] = + static nsAtom* effectSetPropertyAtoms[] = { nsGkAtoms::animationEffectsProperty, nsGkAtoms::animationEffectsForBeforeProperty, @@ -129,7 +129,7 @@ EffectSet::GetEffectSetPropertyAtoms() return effectSetPropertyAtoms; } -/* static */ nsIAtom* +/* static */ nsAtom* EffectSet::GetEffectSetPropertyAtom(CSSPseudoElementType aPseudoType) { switch (aPseudoType) { diff --git a/dom/animation/EffectSet.h b/dom/animation/EffectSet.h index 4e30397c6de2..eb382e1007c7 100644 --- a/dom/animation/EffectSet.h +++ b/dom/animation/EffectSet.h @@ -53,7 +53,7 @@ public: "enumerated"); MOZ_COUNT_DTOR(EffectSet); } - static void PropertyDtor(void* aObject, nsIAtom* aPropertyName, + static void PropertyDtor(void* aObject, nsAtom* aPropertyName, void* aPropertyValue, void* aData); // Methods for supporting cycle-collection @@ -192,7 +192,7 @@ public: void UpdateAnimationGeneration(nsPresContext* aPresContext); uint64_t GetAnimationGeneration() const { return mAnimationGeneration; } - static nsIAtom** GetEffectSetPropertyAtoms(); + static nsAtom** GetEffectSetPropertyAtoms(); nsCSSPropertyIDSet& PropertiesWithImportantRules() { @@ -208,7 +208,7 @@ public: } private: - static nsIAtom* GetEffectSetPropertyAtom(CSSPseudoElementType aPseudoType); + static nsAtom* GetEffectSetPropertyAtom(CSSPseudoElementType aPseudoType); OwningEffectSet mEffects; diff --git a/dom/animation/KeyframeEffectReadOnly.cpp b/dom/animation/KeyframeEffectReadOnly.cpp index 299bbb4664f6..57feb7ca0693 100644 --- a/dom/animation/KeyframeEffectReadOnly.cpp +++ b/dom/animation/KeyframeEffectReadOnly.cpp @@ -1026,7 +1026,7 @@ KeyframeEffectReadOnly::GetTargetStyleContext() MOZ_ASSERT(mTarget, "Should only have a presshell when we have a target element"); - nsIAtom* pseudo = mTarget->mPseudoType < CSSPseudoElementType::Count + nsAtom* pseudo = mTarget->mPseudoType < CSSPseudoElementType::Count ? nsCSSPseudoElements::GetPseudoAtom(mTarget->mPseudoType) : nullptr; diff --git a/dom/asmjscache/AsmJSCache.cpp b/dom/asmjscache/AsmJSCache.cpp index ed1b27965b12..d29239a7600b 100644 --- a/dom/asmjscache/AsmJSCache.cpp +++ b/dom/asmjscache/AsmJSCache.cpp @@ -28,7 +28,7 @@ #include "mozilla/ipc/PBackgroundChild.h" #include "mozilla/Unused.h" #include "nsAutoPtr.h" -#include "nsIAtom.h" +#include "nsAtom.h" #include "nsIFile.h" #include "nsIIPCBackgroundChildCreateCallback.h" #include "nsIPrincipal.h" diff --git a/dom/base/AnonymousContent.cpp b/dom/base/AnonymousContent.cpp index 53beaf0dd0cf..40a5ffe1c36e 100644 --- a/dom/base/AnonymousContent.cpp +++ b/dom/base/AnonymousContent.cpp @@ -187,13 +187,13 @@ Element* AnonymousContent::GetElementById(const nsAString& aElementId) { // This can be made faster in the future if needed. - RefPtr elementId = NS_Atomize(aElementId); + RefPtr elementId = NS_Atomize(aElementId); for (nsIContent* node = mContentNode; node; node = node->GetNextNode(mContentNode)) { if (!node->IsElement()) { continue; } - nsIAtom* id = node->AsElement()->GetID(); + nsAtom* id = node->AsElement()->GetID(); if (id && id == elementId) { return node->AsElement(); } diff --git a/dom/base/Attr.cpp b/dom/base/Attr.cpp index 84ce19ea2dd5..0eb44dfe5516 100644 --- a/dom/base/Attr.cpp +++ b/dom/base/Attr.cpp @@ -164,7 +164,7 @@ Attr::GetValue(nsAString& aValue) { Element* element = GetElement(); if (element) { - RefPtr nameAtom = mNodeInfo->NameAtom(); + RefPtr nameAtom = mNodeInfo->NameAtom(); element->GetAttr(mNodeInfo->NamespaceID(), nameAtom, aValue); } else { @@ -183,7 +183,7 @@ Attr::SetValue(const nsAString& aValue, ErrorResult& aRv) return; } - RefPtr nameAtom = mNodeInfo->NameAtom(); + RefPtr nameAtom = mNodeInfo->NameAtom(); aRv = element->SetAttr(mNodeInfo->NamespaceID(), nameAtom, mNodeInfo->GetPrefixAtom(), diff --git a/dom/base/CustomElementRegistry.cpp b/dom/base/CustomElementRegistry.cpp index 081b02a6b61c..82fb409994a5 100644 --- a/dom/base/CustomElementRegistry.cpp +++ b/dom/base/CustomElementRegistry.cpp @@ -127,12 +127,12 @@ CustomElementConstructor::Construct(const char* aExecutionReason, //----------------------------------------------------- // CustomElementData -CustomElementData::CustomElementData(nsIAtom* aType) +CustomElementData::CustomElementData(nsAtom* aType) : CustomElementData(aType, CustomElementData::State::eUndefined) { } -CustomElementData::CustomElementData(nsIAtom* aType, State aState) +CustomElementData::CustomElementData(nsAtom* aType, State aState) : mType(aType) , mElementIsBeingCreated(false) , mCreatedCallbackInvoked(true) @@ -230,8 +230,8 @@ CustomElementDefinition* CustomElementRegistry::LookupCustomElementDefinition(const nsAString& aLocalName, const nsAString* aIs) const { - RefPtr localNameAtom = NS_Atomize(aLocalName); - RefPtr typeAtom = aIs ? NS_Atomize(*aIs) : localNameAtom; + RefPtr localNameAtom = NS_Atomize(aLocalName); + RefPtr typeAtom = aIs ? NS_Atomize(*aIs) : localNameAtom; CustomElementDefinition* data = mCustomDefinitions.GetWeak(typeAtom); if (data && data->mLocalName == localNameAtom) { @@ -259,14 +259,14 @@ CustomElementRegistry::LookupCustomElementDefinition(JSContext* aCx, } void -CustomElementRegistry::RegisterUnresolvedElement(Element* aElement, nsIAtom* aTypeName) +CustomElementRegistry::RegisterUnresolvedElement(Element* aElement, nsAtom* aTypeName) { mozilla::dom::NodeInfo* info = aElement->NodeInfo(); // Candidate may be a custom element through extension, // in which case the custom element type name will not // match the element tag name. e.g.