Merge inbound to mozilla-central. a=merge
authorNoemi Erli <nerli@mozilla.com>
Thu, 19 Apr 2018 12:53:30 +0300
changeset 467979 8ed49dd81059dfdd876cf62ad5def1cfa56ffbbf
parent 467950 2c32c973232d7362ca9dfe103e1c3a4863e9a423 (current diff)
parent 467978 837f9a0480fb9fd4d22f4c45baf36abdd90314df (diff)
child 467980 3cc613bf13443acc2fea4804872fb3ca56757181
child 468001 04c3950aaad9164a74d514d3292c45ac235a7e91
child 468061 f4f07a24b951dd9c94eb3775a7b58c534fb9d524
push id9165
push userasasaki@mozilla.com
push dateThu, 26 Apr 2018 21:04:54 +0000
treeherdermozilla-beta@064c3804de2e [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmerge
milestone61.0a1
first release with
nightly linux32
8ed49dd81059 / 61.0a1 / 20180419100148 / files
nightly linux64
8ed49dd81059 / 61.0a1 / 20180419100148 / files
nightly mac
8ed49dd81059 / 61.0a1 / 20180419100148 / files
nightly win32
8ed49dd81059 / 61.0a1 / 20180419100148 / files
nightly win64
8ed49dd81059 / 61.0a1 / 20180419100148 / files
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
releases
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Merge inbound to mozilla-central. a=merge
devtools/client/themes/common.css
modules/libpref/init/all.js
servo/components/style/gecko/generated/atom_macro.rs
servo/components/style/gecko/generated/bindings.rs
servo/components/style/gecko/generated/pseudo_element_definition.rs
servo/components/style/gecko/generated/structs.rs
--- a/devtools/client/shared/autocomplete-popup.js
+++ b/devtools/client/shared/autocomplete-popup.js
@@ -5,16 +5,17 @@
 
 "use strict";
 
 const HTML_NS = "http://www.w3.org/1999/xhtml";
 const Services = require("Services");
 const {HTMLTooltip} = require("devtools/client/shared/widgets/tooltip/HTMLTooltip");
 const EventEmitter = require("devtools/shared/event-emitter");
 const {PrefObserver} = require("devtools/client/shared/prefs");
+const {colorUtils} = require("devtools/shared/css/color");
 
 let itemIdCounter = 0;
 /**
  * Autocomplete popup UI implementation.
  *
  * @constructor
  * @param {Document} toolboxDoc
  *        The toolbox document to attach the autocomplete popup panel.
@@ -456,18 +457,25 @@ AutocompletePopup.prototype = {
       listItem.appendChild(preDesc);
       label.textContent = item.label.slice(item.preLabel.length);
     }
 
     listItem.appendChild(label);
 
     if (item.postLabel) {
       let postDesc = this._document.createElementNS(HTML_NS, "span");
+      postDesc.className = "autocomplete-postlabel";
       postDesc.textContent = item.postLabel;
-      postDesc.className = "autocomplete-postlabel";
+      // Determines if the postlabel is a valid colour or other value
+      if (this._isValidColor(item.postLabel)) {
+        let colorSwatch = this._document.createElementNS(HTML_NS, "span");
+        colorSwatch.className = "autocomplete-swatch autocomplete-colorswatch";
+        colorSwatch.style.cssText = "background-color: " + item.postLabel;
+        postDesc.insertBefore(colorSwatch, postDesc.childNodes[0]);
+      }
       listItem.appendChild(postDesc);
     }
 
     if (item.count && item.count > 1) {
       let countDesc = this._document.createElementNS(HTML_NS, "span");
       countDesc.textContent = item.count;
       countDesc.setAttribute("flex", "1");
       countDesc.className = "autocomplete-count";
@@ -599,16 +607,28 @@ AutocompletePopup.prototype = {
     this._tooltip.panel.classList.toggle(newValue + "-theme", true);
     this._list.classList.toggle(oldValue + "-theme", false);
     this._list.classList.toggle(newValue + "-theme", true);
 
     this._currentTheme = newValue;
   },
 
   /**
+  * Determines if the specified colour object is a valid colour, and if
+  * it is not a "special value"
+  *
+  * @return {Boolean}
+  *         If the object represents a proper colour or not.
+  */
+  _isValidColor: function(color) {
+    let colorObj = new colorUtils.CssColor(color);
+    return (colorObj.valid && (!colorObj.specialValue));
+  },
+
+  /**
    * Used by tests.
    */
   get _panel() {
     return this._tooltip.panel;
   },
 
   /**
    * Used by tests.
--- a/devtools/client/shared/test/browser_inplace-editor_autocomplete_css_variable.js
+++ b/devtools/client/shared/test/browser_inplace-editor_autocomplete_css_variable.js
@@ -10,45 +10,59 @@ const { InplaceEditor } = require("devto
 loadHelperScript("helper_inplace_editor.js");
 
 // Test the inplace-editor autocomplete popup for variable suggestions.
 // Using a mocked list of CSS variables to avoid test failures linked to
 // engine changes (new property, removed property, ...).
 // Also using a mocked list of CSS properties to avoid autocompletion when
 // typing in "var"
 
+// Used for representing the expectation of a visible color swatch
+const COLORSWATCH = true;
 // format :
 //  [
 //    what key to press,
 //    expected input box value after keypress,
 //    selected suggestion index (-1 if popup is hidden),
 //    number of suggestions in the popup (0 if popup is hidden),
 //    expected post label corresponding with the input box value,
+//    boolean representing if there should be a colour swatch visible,
 //  ]
 const testData = [
-  ["v", "v", -1, 0, null],
-  ["a", "va", -1, 0, null],
-  ["r", "var", -1, 0, null],
-  ["(", "var()", -1, 0, null],
-  ["-", "var(--abc)", 0, 4, "blue"],
-  ["VK_BACK_SPACE", "var(-)", -1, 0, null],
-  ["-", "var(--abc)", 0, 4, "blue"],
-  ["VK_DOWN", "var(--def)", 1, 4, "red"],
-  ["VK_DOWN", "var(--ghi)", 2, 4, "green"],
-  ["VK_DOWN", "var(--jkl)", 3, 4, "yellow"],
-  ["VK_DOWN", "var(--abc)", 0, 4, "blue"],
-  ["VK_DOWN", "var(--def)", 1, 4, "red"],
-  ["VK_LEFT", "var(--def)", -1, 0, null],
+  ["v", "v", -1, 0, null, !COLORSWATCH],
+  ["a", "va", -1, 0, null, !COLORSWATCH],
+  ["r", "var", -1, 0, null, !COLORSWATCH],
+  ["(", "var()", -1, 0, null, !COLORSWATCH],
+  ["-", "var(--abc)", 0, 9, "inherit", !COLORSWATCH],
+  ["VK_BACK_SPACE", "var(-)", -1, 0, null, !COLORSWATCH],
+  ["-", "var(--abc)", 0, 9, "inherit", !COLORSWATCH],
+  ["VK_DOWN", "var(--def)", 1, 9, "transparent", !COLORSWATCH],
+  ["VK_DOWN", "var(--ghi)", 2, 9, "#00FF00", COLORSWATCH],
+  ["VK_DOWN", "var(--jkl)", 3, 9, "rgb(255, 0, 0)", COLORSWATCH],
+  ["VK_DOWN", "var(--mno)", 4, 9, "hsl(120, 60%, 70%)", COLORSWATCH],
+  ["VK_DOWN", "var(--pqr)", 5, 9, "BlueViolet", COLORSWATCH],
+  ["VK_DOWN", "var(--stu)", 6, 9, "15px", !COLORSWATCH],
+  ["VK_DOWN", "var(--vwx)", 7, 9, "rgba(255, 0, 0, 0.4)", COLORSWATCH],
+  ["VK_DOWN", "var(--yz)", 8, 9, "hsla(120, 60%, 70%, 0.3)", COLORSWATCH],
+  ["VK_DOWN", "var(--abc)", 0, 9, "inherit", !COLORSWATCH],
+  ["VK_DOWN", "var(--def)", 1, 9, "transparent", !COLORSWATCH],
+  ["VK_DOWN", "var(--ghi)", 2, 9, "#00FF00", COLORSWATCH],
+  ["VK_LEFT", "var(--ghi)", -1, 0, null, !COLORSWATCH],
 ];
 
 const CSS_VARIABLES = [
-  ["--abc", "blue"],
-  ["--def", "red"],
-  ["--ghi", "green"],
-  ["--jkl", "yellow"]
+  ["--abc", "inherit"],
+  ["--def", "transparent"],
+  ["--ghi", "#00FF00"],
+  ["--jkl", "rgb(255, 0, 0)"],
+  ["--mno", "hsl(120, 60%, 70%)"],
+  ["--pqr", "BlueViolet"],
+  ["--stu", "15px"],
+  ["--vwx", "rgba(255, 0, 0, 0.4)"],
+  ["--yz", "hsla(120, 60%, 70%, 0.3)"],
 ];
 
 const mockGetCSSValuesForPropertyName = function(propertyName) {
   return [];
 };
 
 add_task(async function() {
   await addTab("data:text/html;charset=utf-8,inplace editor CSS variable autocomplete");
--- a/devtools/client/shared/test/helper_inplace_editor.js
+++ b/devtools/client/shared/test/helper_inplace_editor.js
@@ -6,16 +6,17 @@
 "use strict";
 
 /**
  * Helper methods for the HTMLTooltip integration tests.
  */
 
 const HTML_NS = "http://www.w3.org/1999/xhtml";
 const { editableField } = require("devtools/client/shared/inplace-editor");
+const {colorUtils} = require("devtools/shared/css/color");
 
 /**
  * Create an inplace editor linked to a span element and click on the span to
  * to turn to edit mode.
  *
  * @param {Object} options
  *        Options passed to the InplaceEditor/editableField constructor.
  * @param {Document} doc
@@ -68,20 +69,22 @@ function createSpan(doc) {
  * autocompletion works as expected.
  *
  * @param {Array} testData
  *        - {String} key, the key to send
  *        - {String} completion, the expected value of the auto-completion
  *        - {Number} index, the index of the selected suggestion in the popup
  *        - {Number} total, the total number of suggestions in the popup
  *        - {String} postLabel, the expected post label for the selected suggestion
+ *        - {Boolean} colorSwatch, if there is a swatch of color expected to be visible
  * @param {InplaceEditor} editor
  *        The InplaceEditor instance being tested
  */
-async function testCompletion([key, completion, index, total, postLabel], editor) {
+async function testCompletion([key, completion, index, total,
+    postLabel, colorSwatch], editor) {
   info("Pressing key " + key);
   info("Expecting " + completion);
 
   let onVisibilityChange = null;
   let open = total > 0;
   if (editor.popup.isOpen != open) {
     onVisibilityChange = editor.popup.once(open ? "popup-opened" : "popup-closed");
   }
@@ -107,16 +110,31 @@ async function testCompletion([key, comp
     is(editor.input.value, completion, "Correct value is autocompleted");
   }
 
   if (postLabel) {
     let selectedItem = editor.popup.getItems()[index];
     let selectedElement = editor.popup.elements.get(selectedItem);
     ok(selectedElement.textContent.includes(postLabel),
       "Selected popup element contains the expected post-label");
+
+    // Determines if there is a color swatch attached to the label
+    // and if the color swatch's background color matches the post label
+    let swatchSpan = selectedElement.getElementsByClassName(
+      "autocomplete-swatch autocomplete-colorswatch");
+    if (colorSwatch) {
+      ok(swatchSpan.length === 1, "Displayed the expected color swatch");
+      let color = new colorUtils.CssColor(swatchSpan[0].style.backgroundColor);
+      let swatchColor = color.rgba;
+      color.newColor(postLabel);
+      let postColor = color.rgba;
+      ok(swatchColor == postColor, "Color swatch matches postLabel value");
+    } else {
+      ok(swatchSpan.length === 0, "As expected no swatches were available");
+    }
   }
 
   if (total === 0) {
     ok(!(editor.popup && editor.popup.isOpen), "Popup is closed");
   } else {
     ok(editor.popup.isOpen, "Popup is open");
     is(editor.popup.getItems().length, total, "Number of suggestions match");
     is(editor.popup.selectedIndex, index, "Expected item is selected");
--- a/devtools/client/themes/common.css
+++ b/devtools/client/themes/common.css
@@ -103,16 +103,45 @@ html|button, html|select {
   font-style: italic;
   float: right;
 }
 
 .devtools-autocomplete-listbox .autocomplete-item > .autocomplete-count {
   text-align: end;
 }
 
+.devtools-autocomplete-listbox .autocomplete-swatch {
+  cursor: pointer;
+  border-radius: 50%;
+  width: 1em;
+  height: 1em;
+  vertical-align: middle;
+  /* align the swatch with its value */
+  margin-top: -1px;
+  margin-inline-end: 5px;
+  display: inline-block;
+  position: relative;
+}
+
+.devtools-autocomplete-listbox .autocomplete-colorswatch::before {
+  content: '';
+  background-color: #eee;
+  background-image: linear-gradient(45deg, #ccc 25%, transparent 25%, transparent 75%, #ccc 75%, #ccc),
+                    linear-gradient(45deg, #ccc 25%, transparent 25%, transparent 75%, #ccc 75%, #ccc);
+  background-size: 12px 12px;
+  background-position: 0 0, 6px 6px;
+  position: absolute;
+  border-radius: 50%;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  z-index: -1;
+}
+
 /* Rest of the dark and light theme */
 
 .devtools-autocomplete-popup,
 .CodeMirror-hints,
 .CodeMirror-Tern-tooltip {
   border: 1px solid hsl(210,24%,90%);
   background-image: linear-gradient(to bottom, hsla(209,18%,100%,0.9), hsl(210,24%,95%));
 }
--- a/dom/base/StructuredCloneBlob.cpp
+++ b/dom/base/StructuredCloneBlob.cpp
@@ -168,25 +168,19 @@ StructuredCloneBlob::WriteStructuredClon
   if (!JS_WriteUint32Pair(aWriter, SCTAG_DOM_STRUCTURED_CLONE_HOLDER, 0) ||
       !JS_WriteUint32Pair(aWriter, data.Size(), JS_STRUCTURED_CLONE_VERSION) ||
       !JS_WriteUint32Pair(aWriter, aHolder->BlobImpls().Length(), BlobImpls().Length())) {
     return false;
   }
 
   aHolder->BlobImpls().AppendElements(BlobImpls());
 
-  auto iter = data.Iter();
-  while (!iter.Done()) {
-    if (!JS_WriteBytes(aWriter, iter.Data(), iter.RemainingInSegment())) {
-      return false;
-    }
-    iter.Advance(data, iter.RemainingInSegment());
-  }
-
-  return true;
+  return data.ForEachDataChunk([&](const char* aData, size_t aSize) {
+      return JS_WriteBytes(aWriter, aData, aSize);
+  });
 }
 
 bool
 StructuredCloneBlob::WrapObject(JSContext* aCx, JS::HandleObject aGivenProto, JS::MutableHandleObject aResult)
 {
     return StructuredCloneHolderBinding::Wrap(aCx, this, aGivenProto, aResult);
 }
 
--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -4766,16 +4766,20 @@ nsIDocument::SetContainer(nsDocShell* aC
 {
   if (aContainer) {
     mDocumentContainer = aContainer;
   } else {
     mDocumentContainer = WeakPtr<nsDocShell>();
   }
 
   EnumerateActivityObservers(NotifyActivityChanged, nullptr);
+
+  // IsTopLevelWindowInactive depends on the docshell, so
+  // update the cached value now that it's available.
+  UpdateDocumentStates(NS_DOCUMENT_STATE_WINDOW_INACTIVE);
   if (!aContainer) {
     return;
   }
 
   // Get the Docshell
   if (aContainer->ItemType() == nsIDocShellTreeItem::typeContent) {
     // check if same type root
     nsCOMPtr<nsIDocShellTreeItem> sameTypeRoot;
--- a/dom/base/nsStructuredCloneContainer.cpp
+++ b/dom/base/nsStructuredCloneContainer.cpp
@@ -132,17 +132,17 @@ nsStructuredCloneContainer::GetDataAsBas
   if (!DataLength()) {
     return NS_ERROR_FAILURE;
   }
 
   if (HasClonedDOMObjects()) {
     return NS_ERROR_FAILURE;
   }
 
-  auto iter = Data().Iter();
+  auto iter = Data().Start();
   size_t size = Data().Size();
   nsAutoCString binaryData;
   binaryData.SetLength(size);
   Data().ReadBytes(iter, binaryData.BeginWriting(), size);
   nsAutoCString base64Data;
   nsresult rv = Base64Encode(binaryData, base64Data);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
--- a/dom/indexedDB/ActorsParent.cpp
+++ b/dom/indexedDB/ActorsParent.cpp
@@ -8309,22 +8309,22 @@ struct ObjectStoreAddOrPutRequestOp::Sto
     }
   }
 };
 
 class ObjectStoreAddOrPutRequestOp::SCInputStream final
   : public nsIInputStream
 {
   const JSStructuredCloneData& mData;
-  JSStructuredCloneData::IterImpl mIter;
+  JSStructuredCloneData::Iterator mIter;
 
 public:
   explicit SCInputStream(const JSStructuredCloneData& aData)
     : mData(aData)
-    , mIter(aData.Iter())
+    , mIter(aData.Start())
   { }
 
 private:
   virtual ~SCInputStream() = default;
 
   NS_DECL_THREADSAFE_ISUPPORTS
   NS_DECL_NSIINPUTSTREAM
 };
@@ -19690,17 +19690,17 @@ DatabaseOperationBase::GetStructuredClon
 
   char* uncompressedBuffer = reinterpret_cast<char*>(uncompressed.Elements());
 
   if (NS_WARN_IF(!snappy::RawUncompress(compressed, compressedLength,
                                         uncompressedBuffer))) {
     return NS_ERROR_FILE_CORRUPTED;
   }
 
-  if (!aInfo->mData.WriteBytes(uncompressedBuffer, uncompressed.Length())) {
+  if (!aInfo->mData.AppendBytes(uncompressedBuffer, uncompressed.Length())) {
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   if (!aFileIds.IsVoid()) {
     nsresult rv = DeserializeStructuredCloneFiles(aFileManager,
                                                   aFileIds,
                                                   aInfo->mFiles,
                                                   &aInfo->mHasPreprocessInfo);
@@ -19775,17 +19775,17 @@ DatabaseOperationBase::GetStructuredClon
     if (NS_WARN_IF(NS_FAILED(rv))) {
       break;
     }
 
     if (!numRead) {
       break;
     }
 
-    if (NS_WARN_IF(!aInfo->mData.WriteBytes(buffer, numRead))) {
+    if (NS_WARN_IF(!aInfo->mData.AppendBytes(buffer, numRead))) {
       rv = NS_ERROR_OUT_OF_MEMORY;
       break;
     }
   } while (true);
 
   return rv;
 }
 
@@ -26176,28 +26176,19 @@ ObjectStoreAddOrPutRequestOp::DoDatabase
       uint64_t keyPropValue =
         ReinterpretDoubleAsUInt64(static_cast<double>(autoIncrementNum));
 
       static const size_t keyPropSize = sizeof(uint64_t);
 
       char keyPropBuffer[keyPropSize];
       LittleEndian::writeUint64(keyPropBuffer, keyPropValue);
 
-      auto iter = cloneData.Iter();
-      DebugOnly<bool> result =
-       iter.AdvanceAcrossSegments(cloneData, cloneInfo.offsetToKeyProp());
-      MOZ_ASSERT(result);
-
-      for (char index : keyPropBuffer) {
-        char* keyPropPointer = iter.Data();
-        *keyPropPointer = index;
-
-        result = iter.AdvanceAcrossSegments(cloneData, 1);
-        MOZ_ASSERT(result);
-      }
+      auto iter = cloneData.Start();
+      MOZ_ALWAYS_TRUE(cloneData.Advance(iter, cloneInfo.offsetToKeyProp()));
+      MOZ_ALWAYS_TRUE(cloneData.UpdateBytes(iter, keyPropBuffer, keyPropSize));
     }
   }
 
   key.BindToStatement(stmt, NS_LITERAL_CSTRING("key"));
 
   if (mDataOverThreshold) {
     // The data we store in the SQLite database is a (signed) 64-bit integer.
     // The flags are left-shifted 32 bits so the max value is 0xFFFFFFFF.
@@ -26213,17 +26204,17 @@ ObjectStoreAddOrPutRequestOp::DoDatabase
 
     rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("data"), data);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
   } else {
     nsCString flatCloneData;
     flatCloneData.SetLength(cloneDataSize);
-    auto iter = cloneData.Iter();
+    auto iter = cloneData.Start();
     cloneData.ReadBytes(iter, flatCloneData.BeginWriting(), cloneDataSize);
 
     // Compress the bytes before adding into the database.
     const char* uncompressed = flatCloneData.BeginReading();
     size_t uncompressedLength = cloneDataSize;
 
     size_t compressedLength = snappy::MaxCompressedLength(uncompressedLength);
 
@@ -26473,17 +26464,17 @@ SCInputStream::ReadSegments(nsWriteSegme
     }
 
     // Writer should write what we asked it to write.
     MOZ_ASSERT(written == count);
 
     *_retval += count;
     aCount -= count;
 
-    mIter.Advance(mData, count);
+    mData.Advance(mIter, count);
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 ObjectStoreAddOrPutRequestOp::
 SCInputStream::IsNonBlocking(bool* _retval)
--- a/dom/ipc/StructuredCloneData.cpp
+++ b/dom/ipc/StructuredCloneData.cpp
@@ -143,17 +143,17 @@ enum ManagerFlavorEnum {
 };
 
 template<typename M>
 bool
 BuildClonedMessageData(M* aManager, StructuredCloneData& aData,
                        ClonedMessageData& aClonedData)
 {
   SerializedStructuredCloneBuffer& buffer = aClonedData.data();
-  auto iter = aData.Data().Iter();
+  auto iter = aData.Data().Start();
   size_t size = aData.Data().Size();
   bool success;
   buffer.data = aData.Data().Borrow<js::SystemAllocPolicy>(iter, size, &success);
   if (NS_WARN_IF(!success)) {
     return false;
   }
   if (aData.SupportsTransferring()) {
     aClonedData.identfiers().AppendElements(aData.PortIdentifiers());
--- a/dom/ipc/StructuredCloneData.h
+++ b/dom/ipc/StructuredCloneData.h
@@ -50,31 +50,27 @@ public:
   explicit SharedJSAllocatedData(JSStructuredCloneData&& aData)
     : mData(Move(aData))
   { }
 
   static already_AddRefed<SharedJSAllocatedData>
   CreateFromExternalData(const char* aData, size_t aDataLength)
   {
     JSStructuredCloneData buf;
-    buf.WriteBytes(aData, aDataLength);
+    buf.AppendBytes(aData, aDataLength);
     RefPtr<SharedJSAllocatedData> sharedData =
       new SharedJSAllocatedData(Move(buf));
     return sharedData.forget();
   }
 
   static already_AddRefed<SharedJSAllocatedData>
   CreateFromExternalData(const JSStructuredCloneData& aData)
   {
     JSStructuredCloneData buf;
-    auto iter = aData.Iter();
-    while (!iter.Done()) {
-      buf.WriteBytes(iter.Data(), iter.RemainingInSegment());
-      iter.Advance(aData, iter.RemainingInSegment());
-    }
+    buf.Append(aData);
     RefPtr<SharedJSAllocatedData> sharedData =
       new SharedJSAllocatedData(Move(buf));
     return sharedData.forget();
   }
 
   NS_INLINE_DECL_REFCOUNTING(SharedJSAllocatedData)
 
   JSStructuredCloneData& Data() { return mData; }
@@ -233,17 +229,17 @@ public:
   void StealFromClonedMessageDataForBackgroundChild(ClonedMessageData& aClonedData);
 
 
   // Initialize this instance, borrowing the contents of the given
   // JSStructuredCloneData.  You are responsible for ensuring that this
   // StructuredCloneData instance is destroyed before aData is destroyed.
   bool UseExternalData(const JSStructuredCloneData& aData)
   {
-    auto iter = aData.Iter();
+    auto iter = aData.Start();
     bool success = false;
     mExternalData =
       aData.Borrow<js::SystemAllocPolicy>(iter, aData.Size(), &success);
     mInitialized = true;
     return success;
   }
 
   // Initialize this instance by copying the given data that probably came from
--- a/dom/workers/WorkerPrivate.cpp
+++ b/dom/workers/WorkerPrivate.cpp
@@ -1772,17 +1772,17 @@ WorkerPrivate::Start()
     }
   }
 
   return false;
 }
 
 // aCx is null when called from the finalizer
 bool
-WorkerPrivate::NotifyPrivate(WorkerStatus aStatus)
+WorkerPrivate::Notify(WorkerStatus aStatus)
 {
   AssertIsOnParentThread();
 
   bool pending;
   {
     MutexAutoLock lock(mMutex);
 
     if (mParentStatus >= aStatus) {
@@ -4340,17 +4340,17 @@ WorkerPrivate::AssertValidSyncLoop(nsIEv
     }
   }
 
   MOZ_ASSERT(valid);
 }
 #endif
 
 void
-WorkerPrivate::PostMessageToParentInternal(
+WorkerPrivate::PostMessageToParent(
                             JSContext* aCx,
                             JS::Handle<JS::Value> aMessage,
                             const Sequence<JSObject*>& aTransferable,
                             ErrorResult& aRv)
 {
   AssertIsOnWorkerThread();
 
   JS::Rooted<JS::Value> transferable(aCx, JS::UndefinedValue());
--- a/dom/workers/WorkerPrivate.h
+++ b/dom/workers/WorkerPrivate.h
@@ -153,38 +153,34 @@ public:
   }
 
   // May be called on any thread...
   bool
   Start();
 
   // Called on the parent thread.
   bool
-  Notify(WorkerStatus aStatus)
-  {
-    return NotifyPrivate(aStatus);
-  }
+  Notify(WorkerStatus aStatus);
 
   bool
   Cancel()
   {
     return Notify(Canceling);
   }
 
   bool
   Kill()
   {
     return Notify(Killing);
   }
 
   bool
   Terminate()
   {
-    AssertIsOnParentThread();
-    return TerminatePrivate();
+    return Notify(Terminating);
   }
 
   bool
   Close();
 
   // The passed principal must be the Worker principal in case of a
   // ServiceWorker and the loading principal for any other type.
   static void
@@ -286,20 +282,17 @@ public:
 
   void
   RemoveChildWorker(WorkerPrivate* aChildWorker);
 
   void
   PostMessageToParent(JSContext* aCx,
                       JS::Handle<JS::Value> aMessage,
                       const Sequence<JSObject*>& aTransferable,
-                      ErrorResult& aRv)
-  {
-    PostMessageToParentInternal(aCx, aMessage, aTransferable, aRv);
-  }
+                      ErrorResult& aRv);
 
   void
   PostMessageToParentMessagePort(JSContext* aCx,
                                  JS::Handle<JS::Value> aMessage,
                                  const Sequence<JSObject*>& aTransferable,
                                  ErrorResult& aRv);
 
   void
@@ -1215,25 +1208,16 @@ private:
                 const nsAString& aScriptURL, bool aIsChromeWorker,
                 WorkerType aWorkerType, const nsAString& aWorkerName,
                 const nsACString& aServiceWorkerScope,
                 WorkerLoadInfo& aLoadInfo);
 
   ~WorkerPrivate();
 
   bool
-  NotifyPrivate(WorkerStatus aStatus);
-
-  bool
-  TerminatePrivate()
-  {
-    return NotifyPrivate(Terminating);
-  }
-
-  bool
   MayContinueRunning()
   {
     AssertIsOnWorkerThread();
 
     WorkerStatus status;
     {
       MutexAutoLock lock(mMutex);
       status = mStatus;
@@ -1274,22 +1258,16 @@ private:
   EnableMemoryReporter();
 
   void
   DisableMemoryReporter();
 
   void
   WaitForWorkerEvents();
 
-  void
-  PostMessageToParentInternal(JSContext* aCx,
-                              JS::Handle<JS::Value> aMessage,
-                              const Sequence<JSObject*>& aTransferable,
-                              ErrorResult& aRv);
-
   // If the worker shutdown status is equal or greater then aFailStatus, this
   // operation will fail and nullptr will be returned. See WorkerHolder.h for
   // more information about the correct value to use.
   already_AddRefed<nsIEventTarget>
   CreateNewSyncLoop(WorkerStatus aFailStatus);
 
   bool
   RunCurrentSyncLoop();
--- a/gfx/2d/ScaledFontMac.cpp
+++ b/gfx/2d/ScaledFontMac.cpp
@@ -73,18 +73,26 @@ ScaledFontMac::CTFontDrawGlyphsFuncT* Sc
 bool ScaledFontMac::sSymbolLookupDone = false;
 
 // Helper to create a CTFont from a CGFont, copying any variations that were
 // set on the original CGFont.
 static CTFontRef
 CreateCTFontFromCGFontWithVariations(CGFontRef aCGFont, CGFloat aSize)
 {
     // Avoid calling potentially buggy variation APIs on pre-Sierra macOS
-    // versions (see bug 1331683)
-    if (!nsCocoaFeatures::OnSierraOrLater()) {
+    // versions (see bug 1331683).
+    //
+    // And on HighSierra, CTFontCreateWithGraphicsFont properly carries over
+    // variation settings from the CGFont to CTFont, so we don't need to do
+    // the extra work here -- and this seems to avoid Core Text crashiness
+    // seen in bug 1454094.
+    //
+    // So we only need to do this "the hard way" on Sierra; on other releases,
+    // just let the standard CTFont function do its thing.
+    if (!nsCocoaFeatures::OnSierraExactly()) {
         return CTFontCreateWithGraphicsFont(aCGFont, aSize, nullptr, nullptr);
     }
 
     CFDictionaryRef vars = CGFontCopyVariations(aCGFont);
     CTFontRef ctFont;
     if (vars) {
         CFDictionaryRef varAttr =
             CFDictionaryCreate(nullptr,
--- a/gfx/cairo/cairo/src/cairo-quartz-font.c
+++ b/gfx/cairo/cairo/src/cairo-quartz-font.c
@@ -335,23 +335,33 @@ const cairo_font_face_backend_t _cairo_q
     _cairo_quartz_font_face_scaled_font_create
 };
 
 // Helper to create a CTFont from a CGFont, copying any variations that were
 // set on the original CGFont.
 static CTFontRef
 CreateCTFontFromCGFontWithVariations(CGFontRef aCGFont, CGFloat aSize)
 {
+    // Declare helper provided by widget/cocoa/nsCocoaFeatures.mm
+    extern bool Gecko_OnSierraExactly();
+
     // Avoid calling potentially buggy variation APIs on pre-Sierra macOS
-    // versions (see bug 1331683)
-    // Declare helper provided by widget/cocoa/nsCocoaFeatures.mm
-    extern bool Gecko_OnSierraOrLater();
-    if (!Gecko_OnSierraOrLater()) {
+    // versions (see bug 1331683).
+    //
+    // And on HighSierra, CTFontCreateWithGraphicsFont properly carries over
+    // variation settings from the CGFont to CTFont, so we don't need to do
+    // the extra work here -- and this seems to avoid Core Text crashiness
+    // seen in bug 1454094.
+    //
+    // So we only need to do this "the hard way" on Sierra; on other releases,
+    // just let the standard CTFont function do its thing.
+    if (!Gecko_OnSierraExactly()) {
         return CTFontCreateWithGraphicsFont(aCGFont, aSize, NULL, NULL);
     }
+
     CFDictionaryRef vars = CGFontCopyVariations(aCGFont);
     CTFontRef ctFont;
     if (vars) {
         CFDictionaryRef varAttr =
             CFDictionaryCreate(NULL,
                                (const void**)&kCTFontVariationAttribute,
                                (const void**)&vars, 1,
                                &kCFTypeDictionaryKeyCallBacks,
--- a/gfx/layers/wr/WebRenderCommandBuilder.cpp
+++ b/gfx/layers/wr/WebRenderCommandBuilder.cpp
@@ -90,17 +90,17 @@ struct BlobItemData
   bool mEmpty;
 
   // properties that are used to emulate layer tree invalidation
   Matrix mMatrix; // updated to track the current transform to device space
   Matrix4x4Flagged mTransform; // only used with nsDisplayTransform items to detect transform changes
   float mOpacity; // only used with nsDisplayOpacity items to detect change to opacity
 
   IntRect mImageRect;
-  IntPoint mGroupOffset;
+  LayerIntPoint mGroupOffset;
 
   BlobItemData(DIGroup* aGroup, nsDisplayItem *aItem)
     : mGroup(aGroup)
   {
     mInvalid = false;
     mEmpty = false;
     mDisplayItemKey = aItem->GetPerFrameKey();
     AddFrame(aItem->Frame());
@@ -282,17 +282,17 @@ struct DIGroup
   nsTHashtable<nsPtrHashKey<BlobItemData>> mDisplayItems;
 
   nsPoint mAnimatedGeometryRootOrigin;
   nsPoint mLastAnimatedGeometryRootOrigin;
   IntRect mInvalidRect;
   nsRect mGroupBounds;
   int32_t mAppUnitsPerDevPixel;
   gfx::Size mScale;
-  IntPoint mGroupOffset;
+  LayerIntRect mLayerBounds;
   Maybe<wr::ImageKey> mKey;
 
   DIGroup() : mAppUnitsPerDevPixel(0) {}
 
   void InvalidateRect(const IntRect& aRect)
   {
     // Empty rects get dropped
     mInvalidRect = mInvalidRect.Union(aRect);
@@ -311,19 +311,19 @@ struct DIGroup
       BlobItemData* data = iter.Get()->GetKey();
       GP("Deleting %p-%d\n", data->mFrame, data->mDisplayItemKey);
       iter.Remove();
       delete data;
     }
   }
 
   static IntRect
-  ToDeviceSpace(nsRect aBounds, Matrix& aMatrix, int32_t aAppUnitsPerDevPixel, IntPoint aOffset)
+  ToDeviceSpace(nsRect aBounds, Matrix& aMatrix, int32_t aAppUnitsPerDevPixel, LayerIntPoint aOffset)
   {
-    return RoundedOut(aMatrix.TransformBounds(ToRect(nsLayoutUtils::RectToGfxRect(aBounds, aAppUnitsPerDevPixel)))) - aOffset;
+    return RoundedOut(aMatrix.TransformBounds(ToRect(nsLayoutUtils::RectToGfxRect(aBounds, aAppUnitsPerDevPixel)))) - aOffset.ToUnknownPoint();
   }
 
   void ComputeGeometryChange(nsDisplayItem* aItem, BlobItemData* aData, Matrix& aMatrix, nsDisplayListBuilder* aBuilder)
   {
     // If the frame is marked as invalidated, and didn't specify a rect to invalidate then we want to
     // invalidate both the old and new bounds, otherwise we only want to invalidate the changed areas.
     // If we do get an invalid rect, then we want to add this on top of the change areas.
     nsRect invalid;
@@ -335,43 +335,42 @@ struct DIGroup
     if (shift.x != 0 || shift.y != 0)
       GP("shift %d %d\n", shift.x, shift.y);
     int32_t appUnitsPerDevPixel = aItem->Frame()->PresContext()->AppUnitsPerDevPixel();
     MOZ_RELEASE_ASSERT(mAppUnitsPerDevPixel == appUnitsPerDevPixel);
     LayoutDeviceRect bounds = LayoutDeviceRect::FromAppUnits(mGroupBounds, appUnitsPerDevPixel);
     LayoutDeviceIntPoint offset = RoundedToInt(bounds.TopLeft());
     GP("\n");
     GP("CGC offset %d %d\n", offset.x, offset.y);
-    IntSize size = mGroupBounds.Size().ScaleToNearestPixels(mScale.width, mScale.height, appUnitsPerDevPixel);
-    //MOZ_RELEASE_ASSERT(mGroupOffset.x == offset.x && mGroupOffset.y == offset.y);
+    LayerIntSize size = mLayerBounds.Size();
     IntRect imageRect(0, 0, size.width, size.height);
     GP("imageSize: %d %d\n", size.width, size.height);
     /*if (aItem->IsReused() && aData->mGeometry) {
       return;
     }*/
 
     GP("pre mInvalidRect: %s %p-%d - inv: %d %d %d %d\n", aItem->Name(), aItem->Frame(), aItem->GetPerFrameKey(),
        mInvalidRect.x, mInvalidRect.y, mInvalidRect.width, mInvalidRect.height);
     if (!aData->mGeometry) {
       // This item is being added for the first time, invalidate its entire area.
       UniquePtr<nsDisplayItemGeometry> geometry(aItem->AllocateGeometry(aBuilder));
       combined = clip.ApplyNonRoundedIntersection(geometry->ComputeInvalidationRegion());
       aData->mGeometry = Move(geometry);
       nsRect bounds = combined.GetBounds();
 
-      IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mGroupOffset);
+      IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());
       aData->mRect = transformedRect.Intersect(imageRect);
       GP("CGC %s %d %d %d %d\n", aItem->Name(), bounds.x, bounds.y, bounds.width, bounds.height);
-      GP("%d %d,  %f %f\n", mGroupOffset.x, mGroupOffset.y, aMatrix._11, aMatrix._22);
+      GP("%d %d,  %f %f\n", mLayerBounds.TopLeft().x, mLayerBounds.TopLeft().y, aMatrix._11, aMatrix._22);
       GP("mRect %d %d %d %d\n", aData->mRect.x, aData->mRect.y, aData->mRect.width, aData->mRect.height);
       InvalidateRect(aData->mRect);
       aData->mInvalid = true;
     } else if (/*aData->mIsInvalid || XXX: handle image load invalidation */ (aItem->IsInvalid(invalid) && invalid.IsEmpty())) {
       MOZ_RELEASE_ASSERT(imageRect.IsEqualEdges(aData->mImageRect));
-      MOZ_RELEASE_ASSERT(mGroupOffset == aData->mGroupOffset);
+      MOZ_RELEASE_ASSERT(mLayerBounds.TopLeft() == aData->mGroupOffset);
       UniquePtr<nsDisplayItemGeometry> geometry(aItem->AllocateGeometry(aBuilder));
       /* Instead of doing this dance, let's just invalidate the old rect and the
        * new rect.
       combined = aData->mClip.ApplyNonRoundedIntersection(aData->mGeometry->ComputeInvalidationRegion());
       combined.MoveBy(shift);
       combined.Or(combined, clip.ApplyNonRoundedIntersection(geometry->ComputeInvalidationRegion()));
       aData->mGeometry = Move(geometry);
       */
@@ -383,67 +382,67 @@ struct DIGroup
       GP("old rect: %d %d %d %d\n",
              aData->mRect.x,
              aData->mRect.y,
              aData->mRect.width,
              aData->mRect.height);
       InvalidateRect(aData->mRect.Intersect(imageRect));
       // We want to snap to outside pixels. When should we multiply by the matrix?
       // XXX: TransformBounds is expensive. We should avoid doing it if we have no transform
-      IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mGroupOffset);
+      IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());
       aData->mRect = transformedRect.Intersect(imageRect);
       InvalidateRect(aData->mRect);
       GP("new rect: %d %d %d %d\n",
              aData->mRect.x,
              aData->mRect.y,
              aData->mRect.width,
              aData->mRect.height);
       aData->mInvalid = true;
     } else {
       MOZ_RELEASE_ASSERT(imageRect.IsEqualEdges(aData->mImageRect));
-      MOZ_RELEASE_ASSERT(mGroupOffset == aData->mGroupOffset);
+      MOZ_RELEASE_ASSERT(mLayerBounds.TopLeft() == aData->mGroupOffset);
       GP("else invalidate: %s\n", aItem->Name());
       aData->mGeometry->MoveBy(shift);
       // this includes situations like reflow changing the position
       aItem->ComputeInvalidationRegion(aBuilder, aData->mGeometry.get(), &combined);
       if (!combined.IsEmpty()) {
         // There might be no point in doing this elaborate tracking here to get
         // smaller areas
         InvalidateRect(aData->mRect.Intersect(imageRect)); // invalidate the old area -- in theory combined should take care of this
         UniquePtr<nsDisplayItemGeometry> geometry(aItem->AllocateGeometry(aBuilder));
         aData->mClip.AddOffsetAndComputeDifference(shift, aData->mGeometry->ComputeInvalidationRegion(), clip,
                                                    geometry ? geometry->ComputeInvalidationRegion() :
                                                    aData->mGeometry->ComputeInvalidationRegion(),
                                                    &combined);
-        IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mGroupOffset);
+        IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());
         IntRect invalidRect = transformedRect.Intersect(imageRect);
         GP("combined not empty: mRect %d %d %d %d\n", invalidRect.x, invalidRect.y, invalidRect.width, invalidRect.height);
         // invalidate the invalidated area.
         InvalidateRect(invalidRect);
 
         aData->mGeometry = Move(geometry);
 
         combined = clip.ApplyNonRoundedIntersection(aData->mGeometry->ComputeInvalidationRegion());
-        transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mGroupOffset);
+        transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());
         aData->mRect = transformedRect.Intersect(imageRect);
 
         aData->mInvalid = true;
       } else {
         if (aData->mClip != clip) {
           UniquePtr<nsDisplayItemGeometry> geometry(aItem->AllocateGeometry(aBuilder));
           if (!IsContainerLayerItem(aItem)) {
             // the bounds of layer items can change on us without ComputeInvalidationRegion
             // returning any change. Other items shouldn't have any hidden
             // geometry change.
             MOZ_RELEASE_ASSERT(geometry->mBounds.IsEqualEdges(aData->mGeometry->mBounds));
           } else {
             aData->mGeometry = Move(geometry);
           }
           combined = clip.ApplyNonRoundedIntersection(aData->mGeometry->ComputeInvalidationRegion());
-          IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mGroupOffset);
+          IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());
           InvalidateRect(aData->mRect.Intersect(imageRect));
           aData->mRect = transformedRect.Intersect(imageRect);
           InvalidateRect(aData->mRect);
 
           GP("ClipChange: %s %d %d %d %d\n", aItem->Name(),
                  aData->mRect.x, aData->mRect.y, aData->mRect.XMost(), aData->mRect.YMost());
 
         } else if (!aMatrix.ExactlyEquals(aData->mMatrix)) {
@@ -457,59 +456,59 @@ struct DIGroup
           if (!IsContainerLayerItem(aItem)) {
             // the bounds of layer items can change on us
             // other items shouldn't
             MOZ_RELEASE_ASSERT(geometry->mBounds.IsEqualEdges(aData->mGeometry->mBounds));
           } else {
             aData->mGeometry = Move(geometry);
           }
           combined = clip.ApplyNonRoundedIntersection(aData->mGeometry->ComputeInvalidationRegion());
-          IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mGroupOffset);
+          IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());
           InvalidateRect(aData->mRect.Intersect(imageRect));
           aData->mRect = transformedRect.Intersect(imageRect);
           InvalidateRect(aData->mRect);
 
           GP("TransformChange: %s %d %d %d %d\n", aItem->Name(),
                  aData->mRect.x, aData->mRect.y, aData->mRect.XMost(), aData->mRect.YMost());
         } else if (IsContainerLayerItem(aItem)) {
           UniquePtr<nsDisplayItemGeometry> geometry(aItem->AllocateGeometry(aBuilder));
           // we need to catch bounds changes of containers so that we continue to have the correct bounds rects in the recording
           if (!geometry->mBounds.IsEqualEdges(aData->mGeometry->mBounds) ||
               UpdateContainerLayerPropertiesAndDetectChange(aItem, aData)) {
             combined = clip.ApplyNonRoundedIntersection(geometry->ComputeInvalidationRegion());
             aData->mGeometry = Move(geometry);
-            IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mGroupOffset);
+            IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());
             InvalidateRect(aData->mRect.Intersect(imageRect));
             aData->mRect = transformedRect.Intersect(imageRect);
             InvalidateRect(aData->mRect);
             GP("UpdateContainerLayerPropertiesAndDetectChange change\n");
           } else {
             // XXX: this code can eventually be deleted/made debug only
             combined = clip.ApplyNonRoundedIntersection(geometry->ComputeInvalidationRegion());
-            IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mGroupOffset);
+            IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());
             auto rect = transformedRect.Intersect(imageRect);
             MOZ_RELEASE_ASSERT(rect.IsEqualEdges(aData->mRect));
             GP("Layer NoChange: %s %d %d %d %d\n", aItem->Name(),
                    aData->mRect.x, aData->mRect.y, aData->mRect.XMost(), aData->mRect.YMost());
           }
         } else {
           // XXX: this code can eventually be deleted/made debug only
           UniquePtr<nsDisplayItemGeometry> geometry(aItem->AllocateGeometry(aBuilder));
           combined = clip.ApplyNonRoundedIntersection(geometry->ComputeInvalidationRegion());
-          IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mGroupOffset);
+          IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());
           auto rect = transformedRect.Intersect(imageRect);
           MOZ_RELEASE_ASSERT(rect.IsEqualEdges(aData->mRect));
           GP("NoChange: %s %d %d %d %d\n", aItem->Name(),
                  aData->mRect.x, aData->mRect.y, aData->mRect.XMost(), aData->mRect.YMost());
         }
       }
     }
     aData->mClip = clip;
     aData->mMatrix = aMatrix;
-    aData->mGroupOffset = mGroupOffset;
+    aData->mGroupOffset = mLayerBounds.TopLeft();
     aData->mImageRect = imageRect;
     GP("post mInvalidRect: %d %d %d %d\n", mInvalidRect.x, mInvalidRect.y, mInvalidRect.width, mInvalidRect.height);
   }
 
   void EndGroup(WebRenderLayerManager* aWrManager,
                 wr::DisplayListBuilder& aBuilder,
                 wr::IpcResourceUpdateQueue& aResources,
                 Grouper* aGrouper,
@@ -627,17 +626,17 @@ struct DIGroup
                        mKey.value());
   }
 
   void PaintItemRange(Grouper* aGrouper,
                       nsDisplayItem* aStartItem,
                       nsDisplayItem* aEndItem,
                       gfxContext* aContext,
                       gfx::DrawEventRecorderMemory* aRecorder) {
-    IntSize size = mGroupBounds.Size().ScaleToNearestPixels(mScale.width, mScale.height, aGrouper->mAppUnitsPerDevPixel);
+    LayerIntSize size = mLayerBounds.Size();
     for (nsDisplayItem* item = aStartItem; item != aEndItem; item = item->GetAbove()) {
       IntRect bounds = ItemBounds(item);
       auto bottomRight = bounds.BottomRight();
 
       GP("Trying %s %p-%d %d %d %d %d\n", item->Name(), item->Frame(), item->GetPerFrameKey(), bounds.x, bounds.y, bounds.XMost(), bounds.YMost());
       GP("paint check invalid %d %d - %d %d\n", bottomRight.x, bottomRight.y, size.width, size.height);
       // skip empty items
       if (bounds.IsEmpty()) {
@@ -911,25 +910,27 @@ Grouper::ConstructGroups(WebRenderComman
           groupData->mFollowingGroup.mAppUnitsPerDevPixel != currentGroup->mAppUnitsPerDevPixel) {
         if (groupData->mFollowingGroup.mAppUnitsPerDevPixel != currentGroup->mAppUnitsPerDevPixel) {
           GP("app unit change following: %d %d\n", groupData->mFollowingGroup.mAppUnitsPerDevPixel, currentGroup->mAppUnitsPerDevPixel);
         }
         // The group changed size
         GP("Inner group size change\n");
         groupData->mFollowingGroup.ClearItems();
         if (groupData->mFollowingGroup.mKey) {
-          IntSize size = currentGroup->mGroupBounds.Size().ScaleToNearestPixels(currentGroup->mScale.width, currentGroup->mScale.height, mAppUnitsPerDevPixel);
-          groupData->mFollowingGroup.mInvalidRect = IntRect(IntPoint(0, 0), size);
+          LayerIntRect layerBounds = LayerIntRect::FromUnknownRect(currentGroup->mGroupBounds.ScaleToOutsidePixels(currentGroup->mScale.width,
+                                                                                                                   currentGroup->mScale.height,
+                                                                                                                   mAppUnitsPerDevPixel));
+          groupData->mFollowingGroup.mInvalidRect = IntRect(IntPoint(0, 0), layerBounds.Size().ToUnknownSize());
           aCommandBuilder->mManager->AddImageKeyForDiscard(groupData->mFollowingGroup.mKey.value());
           groupData->mFollowingGroup.mKey = Nothing();
         }
       }
       groupData->mFollowingGroup.mGroupBounds = currentGroup->mGroupBounds;
       groupData->mFollowingGroup.mAppUnitsPerDevPixel = currentGroup->mAppUnitsPerDevPixel;
-      groupData->mFollowingGroup.mGroupOffset = currentGroup->mGroupOffset;
+      groupData->mFollowingGroup.mLayerBounds = currentGroup->mLayerBounds;
       groupData->mFollowingGroup.mScale = currentGroup->mScale;
 
       currentGroup = &groupData->mFollowingGroup;
 
       startOfCurrentGroup = item->GetAbove();
     } else { // inactive item
 
       if (item->GetType() == DisplayItemType::TYPE_TRANSFORM) {
@@ -1054,17 +1055,17 @@ WebRenderCommandBuilder::DoGroupingForDi
       group.mKey = Nothing();
     }
   }
   g.mAppUnitsPerDevPixel = appUnitsPerDevPixel;
   g.mTransform = Matrix::Scaling(scale.width, scale.height);
   group.mAppUnitsPerDevPixel = appUnitsPerDevPixel;
   group.mGroupBounds = groupBounds;
   group.mScale = scale;
-  group.mGroupOffset = group.mGroupBounds.TopLeft().ScaleToNearestPixels(scale.width, scale.height, g.mAppUnitsPerDevPixel);
+  group.mLayerBounds = LayerIntRect::FromUnknownRect(group.mGroupBounds.ScaleToOutsidePixels(scale.width, scale.height, group.mAppUnitsPerDevPixel));
   group.mAnimatedGeometryRootOrigin = group.mGroupBounds.TopLeft();
   g.ConstructGroups(this, aBuilder, aResources, &group, aList, aSc);
   mScrollingHelper.EndList(aSc);
 }
 
 void
 WebRenderCommandBuilder::Destroy()
 {
--- a/gfx/skia/skia/src/ports/SkFontHost_mac.cpp
+++ b/gfx/skia/skia/src/ports/SkFontHost_mac.cpp
@@ -751,17 +751,17 @@ private:
 };
 
 // CTFontCreateCopyWithAttributes or CTFontCreateCopyWithSymbolicTraits cannot be used on 10.10
 // and later, as they will return different underlying fonts depending on the size requested.
 // It is not possible to use descriptors with CTFontCreateWithFontDescriptor, since that does not
 // work with non-system fonts. As a result, create the strike specific CTFonts from the underlying
 // CGFont.
 #ifdef MOZ_SKIA
-extern "C" bool Gecko_OnSierraOrLater();
+extern "C" bool Gecko_OnSierraExactly();
 #endif
 static UniqueCFRef<CTFontRef> ctfont_create_exact_copy(CTFontRef baseFont, CGFloat textSize,
                                                        const CGAffineTransform* transform)
 {
     UniqueCFRef<CGFontRef> baseCGFont(CTFontCopyGraphicsFont(baseFont, nullptr));
 
     // The last parameter (CTFontDescriptorRef attributes) *must* be nullptr.
     // If non-nullptr then with fonts with variation axes, the copy will fail in
@@ -769,18 +769,26 @@ static UniqueCFRef<CTFontRef> ctfont_cre
     // which it quite obviously is not.
 
     // Because we cannot setup the CTFont descriptor to match, the same restriction applies here
     // as other uses of CTFontCreateWithGraphicsFont which is that such CTFonts should not escape
     // the scaler context, since they aren't 'normal'.
 
 #ifdef MOZ_SKIA
     // Avoid calling potentially buggy variation APIs on pre-Sierra macOS
-    // versions (see bug 1331683)
-    if (Gecko_OnSierraOrLater())
+    // versions (see bug 1331683).
+    //
+    // And on HighSierra, CTFontCreateWithGraphicsFont properly carries over
+    // variation settings from the CGFont to CTFont, so we don't need to do
+    // the extra work here -- and this seems to avoid Core Text crashiness
+    // seen in bug 1454094.
+    //
+    // So we only need to do this "the hard way" on Sierra; on other releases,
+    // just let the standard CTFont function do its thing.
+    if (Gecko_OnSierraExactly())
 #endif
     {
         // Not UniqueCFRef<> because CGFontCopyVariations can return null!
         CFDictionaryRef variations = CGFontCopyVariations(baseCGFont.get());
         if (variations) {
             UniqueCFRef<CFDictionaryRef>
                 varAttr(CFDictionaryCreate(nullptr,
                                            (const void**)&kCTFontVariationAttribute,
--- a/gfx/thebes/gfxMacFont.cpp
+++ b/gfx/thebes/gfxMacFont.cpp
@@ -419,18 +419,26 @@ gfxMacFont::GetCharWidth(CFDataRef aCmap
 
 /* static */
 CTFontRef
 gfxMacFont::CreateCTFontFromCGFontWithVariations(CGFontRef aCGFont,
                                                  CGFloat aSize,
                                                  CTFontDescriptorRef aFontDesc)
 {
     // Avoid calling potentially buggy variation APIs on pre-Sierra macOS
-    // versions (see bug 1331683)
-    if (!nsCocoaFeatures::OnSierraOrLater()) {
+    // versions (see bug 1331683).
+    //
+    // And on HighSierra, CTFontCreateWithGraphicsFont properly carries over
+    // variation settings from the CGFont to CTFont, so we don't need to do
+    // the extra work here -- and this seems to avoid Core Text crashiness
+    // seen in bug 1454094.
+    //
+    // So we only need to do this "the hard way" on Sierra; on other releases,
+    // just let the standard CTFont function do its thing.
+    if (!nsCocoaFeatures::OnSierraExactly()) {
         return CTFontCreateWithGraphicsFont(aCGFont, aSize, nullptr, aFontDesc);
     }
 
     CFDictionaryRef variations = ::CGFontCopyVariations(aCGFont);
     CTFontRef ctFont;
     if (variations) {
         CFDictionaryRef varAttr =
             ::CFDictionaryCreate(nullptr,
--- a/ipc/glue/IPCMessageUtils.h
+++ b/ipc/glue/IPCMessageUtils.h
@@ -73,21 +73,17 @@ struct SerializedStructuredCloneBuffer f
   {
     *this = aOther;
   }
 
   SerializedStructuredCloneBuffer&
   operator=(const SerializedStructuredCloneBuffer& aOther)
   {
     data.Clear();
-    auto iter = aOther.data.Iter();
-    while (!iter.Done()) {
-      data.WriteBytes(iter.Data(), iter.RemainingInSegment());
-      iter.Advance(aOther.data, iter.RemainingInSegment());
-    }
+    data.Append(aOther.data);
     return *this;
   }
 
   bool
   operator==(const SerializedStructuredCloneBuffer& aOther) const
   {
     // The copy assignment operator and the equality operator are
     // needed by the IPDL generated code. We relied on the copy
@@ -832,21 +828,19 @@ template <>
 struct ParamTraits<JSStructuredCloneData>
 {
   typedef JSStructuredCloneData paramType;
 
   static void Write(Message* aMsg, const paramType& aParam)
   {
     MOZ_ASSERT(!(aParam.Size() % sizeof(uint64_t)));
     WriteParam(aMsg, aParam.Size());
-    auto iter = aParam.Iter();
-    while (!iter.Done()) {
-      aMsg->WriteBytes(iter.Data(), iter.RemainingInSegment(), sizeof(uint64_t));
-      iter.Advance(aParam, iter.RemainingInSegment());
-    }
+    aParam.ForEachDataChunk([&](const char* aData, size_t aSize) {
+        return aMsg->WriteBytes(aData, aSize, sizeof(uint64_t));
+    });
   }
 
   static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
   {
     size_t length = 0;
     if (!ReadParam(aMsg, aIter, &length)) {
       return false;
     }
--- a/js/public/StructuredClone.h
+++ b/js/public/StructuredClone.h
@@ -5,16 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef js_StructuredClone_h
 #define js_StructuredClone_h
 
 #include "mozilla/Attributes.h"
 #include "mozilla/BufferList.h"
 #include "mozilla/MemoryReporting.h"
+#include "mozilla/Move.h"
 
 #include <stdint.h>
 
 #include "jstypes.h"
 
 #include "js/RootingAPI.h"
 #include "js/TypeDecls.h"
 #include "js/Value.h"
@@ -334,62 +335,148 @@ namespace js
         MOZ_MUST_USE bool acquire(JSContext* cx, SharedArrayRawBuffer* rawbuf);
         MOZ_MUST_USE bool acquireAll(JSContext* cx, const SharedArrayRawBufferRefs& that);
         void takeOwnership(SharedArrayRawBufferRefs&&);
         void releaseAll();
 
       private:
         js::Vector<js::SharedArrayRawBuffer*, 0, js::SystemAllocPolicy> refs_;
     };
+
+    template <typename T, typename AllocPolicy> struct BufferIterator;
 }
 
-class MOZ_NON_MEMMOVABLE JS_PUBLIC_API(JSStructuredCloneData) :
-    public mozilla::BufferList<js::SystemAllocPolicy>
-{
-    typedef js::SystemAllocPolicy AllocPolicy;
-    typedef mozilla::BufferList<js::SystemAllocPolicy> BufferList;
+/**
+ * JSStructuredCloneData represents structured clone data together with the
+ * information needed to read/write/transfer/free the records within it, in the
+ * form of a set of callbacks.
+ */
+class MOZ_NON_MEMMOVABLE JS_PUBLIC_API(JSStructuredCloneData) {
+  public:
+    using BufferList = mozilla::BufferList<js::SystemAllocPolicy>;
+    using Iterator = BufferList::IterImpl;
 
-    static const size_t kInitialSize = 0;
-    static const size_t kInitialCapacity = 4096;
+  private:
     static const size_t kStandardCapacity = 4096;
 
+    BufferList bufList_;
+
     const JSStructuredCloneCallbacks* callbacks_ = nullptr;
     void* closure_ = nullptr;
     OwnTransferablePolicy ownTransferables_ = OwnTransferablePolicy::NoTransferables;
     js::SharedArrayRawBufferRefs refsHeld_;
 
-    void setOptionalCallbacks(const JSStructuredCloneCallbacks* callbacks,
-                              void* closure,
-                              OwnTransferablePolicy policy) {
-        callbacks_ = callbacks;
-        closure_ = closure;
-        ownTransferables_ = policy;
-    }
-
     friend struct JSStructuredCloneWriter;
     friend class JS_PUBLIC_API(JSAutoStructuredCloneBuffer);
+    template <typename T, typename AllocPolicy> friend struct js::BufferIterator;
 
-public:
-    explicit JSStructuredCloneData(AllocPolicy aAP = AllocPolicy())
-        : BufferList(kInitialSize, kInitialCapacity, kStandardCapacity, aAP)
+  public:
+    // The constructor must be infallible but SystemAllocPolicy is not, so both
+    // the initial size and initial capacity of the BufferList must be zero.
+    explicit JSStructuredCloneData()
+        : bufList_(0, 0, kStandardCapacity, js::SystemAllocPolicy())
         , callbacks_(nullptr)
         , closure_(nullptr)
         , ownTransferables_(OwnTransferablePolicy::NoTransferables)
     {}
     MOZ_IMPLICIT JSStructuredCloneData(BufferList&& buffers)
-        : BufferList(Move(buffers))
+        : bufList_(mozilla::Move(buffers))
         , callbacks_(nullptr)
         , closure_(nullptr)
         , ownTransferables_(OwnTransferablePolicy::NoTransferables)
     {}
     JSStructuredCloneData(JSStructuredCloneData&& other) = default;
     JSStructuredCloneData& operator=(JSStructuredCloneData&& other) = default;
-    ~JSStructuredCloneData();
+    ~JSStructuredCloneData() { discardTransferables(); }
+
+    void setCallbacks(const JSStructuredCloneCallbacks* callbacks,
+                      void* closure,
+                      OwnTransferablePolicy policy)
+    {
+        callbacks_ = callbacks;
+        closure_ = closure;
+        ownTransferables_ = policy;
+    }
+
+    bool Init(size_t initialCapacity = 0) { return bufList_.Init(0, initialCapacity); }
+
+    size_t Size() const { return bufList_.Size(); }
+
+    const Iterator Start() const { return bufList_.Iter(); }
+
+    bool Advance(Iterator& iter, size_t distance) const {
+        return iter.AdvanceAcrossSegments(bufList_, distance);
+    }
+
+    bool ReadBytes(Iterator& iter, char* buffer, size_t size) const {
+        return bufList_.ReadBytes(iter, buffer, size);
+    }
+
+    // Append new data to the end of the buffer.
+    bool AppendBytes(const char* data, size_t size) {
+        return bufList_.WriteBytes(data, size);
+    }
+
+    // Update data stored within the existing buffer. There must be at least
+    // 'size' bytes between the position of 'iter' and the end of the buffer.
+    bool UpdateBytes(Iterator& iter, const char* data, size_t size) const {
+        while (size > 0) {
+            size_t remaining = iter.RemainingInSegment();
+            size_t nbytes = std::min(remaining, size);
+            memcpy(iter.Data(), data, nbytes);
+            data += nbytes;
+            size -= nbytes;
+            iter.Advance(bufList_, nbytes);
+        }
+        return true;
+    }
 
-    using BufferList::BufferList;
+    char* AllocateBytes(size_t maxSize, size_t* size) {
+        return bufList_.AllocateBytes(maxSize, size);
+    }
+
+    void Clear() {
+        discardTransferables();
+        bufList_.Clear();
+    }
+
+    template<typename BorrowingAllocPolicy>
+    mozilla::BufferList<BorrowingAllocPolicy> Borrow(Iterator& iter, size_t size, bool* success,
+                                            BorrowingAllocPolicy ap = BorrowingAllocPolicy()) const
+    {
+        return bufList_.Borrow<BorrowingAllocPolicy>(iter, size, success);
+    }
+
+    // Iterate over all contained data, one BufferList segment's worth at a
+    // time, and invoke the given FunctionToApply with the data pointer and
+    // size. The function should return a bool value, and this loop will exit
+    // with false if the function ever returns false.
+    template <typename FunctionToApply>
+    bool ForEachDataChunk(FunctionToApply&& function) const {
+        Iterator iter = bufList_.Iter();
+        while (!iter.Done()) {
+            if (!function(iter.Data(), iter.RemainingInSegment()))
+                return false;
+            iter.Advance(bufList_, iter.RemainingInSegment());
+        }
+        return true;
+    }
+
+    // Append the entire contents of other's bufList_ to our own.
+    bool Append(const JSStructuredCloneData& other) {
+        return other.ForEachDataChunk([&](const char* data, size_t size) {
+            return AppendBytes(data, size);
+        });
+    }
+
+    size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) {
+        return bufList_.SizeOfExcludingThis(mallocSizeOf);
+    }
+
+    void discardTransferables();
 };
 
 /**
  * Implements StructuredDeserialize and StructuredDeserializeWithTransfer.
  *
  * Note: If `data` contains transferable objects, it can be read only once.
  */
 JS_PUBLIC_API(bool)
@@ -415,44 +502,50 @@ JS_WriteStructuredClone(JSContext* cx, J
 
 JS_PUBLIC_API(bool)
 JS_StructuredCloneHasTransferables(JSStructuredCloneData& data, bool* hasTransferable);
 
 JS_PUBLIC_API(bool)
 JS_StructuredClone(JSContext* cx, JS::HandleValue v, JS::MutableHandleValue vp,
                    const JSStructuredCloneCallbacks* optionalCallbacks, void* closure);
 
-/** RAII sugar for JS_WriteStructuredClone. */
+/**
+ * The C-style API calls to read and write structured clones are fragile --
+ * they rely on the caller to properly handle ownership of the clone data, and
+ * the handling of the input data as well as the interpretation of the contents
+ * of the clone buffer are dependent on the callbacks passed in. If you
+ * serialize and deserialize with different callbacks, the results are
+ * questionable.
+ *
+ * JSAutoStructuredCloneBuffer wraps things up in an RAII class for data
+ * management, and uses the same callbacks for both writing and reading
+ * (serializing and deserializing).
+ */
 class JS_PUBLIC_API(JSAutoStructuredCloneBuffer) {
     const JS::StructuredCloneScope scope_;
     JSStructuredCloneData data_;
     uint32_t version_;
 
   public:
     JSAutoStructuredCloneBuffer(JS::StructuredCloneScope scope,
                                 const JSStructuredCloneCallbacks* callbacks, void* closure)
         : scope_(scope), version_(JS_STRUCTURED_CLONE_VERSION)
     {
-        data_.setOptionalCallbacks(callbacks, closure, OwnTransferablePolicy::NoTransferables);
+        data_.setCallbacks(callbacks, closure, OwnTransferablePolicy::NoTransferables);
     }
 
     JSAutoStructuredCloneBuffer(JSAutoStructuredCloneBuffer&& other);
     JSAutoStructuredCloneBuffer& operator=(JSAutoStructuredCloneBuffer&& other);
 
     ~JSAutoStructuredCloneBuffer() { clear(); }
 
     JSStructuredCloneData& data() { return data_; }
     bool empty() const { return !data_.Size(); }
 
-    void clear(const JSStructuredCloneCallbacks* optionalCallbacks=nullptr, void* closure=nullptr);
-
-    /** Copy some memory. It will be automatically freed by the destructor. */
-    bool copy(JSContext* cx, const JSStructuredCloneData& data,
-              uint32_t version=JS_STRUCTURED_CLONE_VERSION,
-              const JSStructuredCloneCallbacks* callbacks=nullptr, void* closure=nullptr);
+    void clear();
 
     /**
      * Adopt some memory. It will be automatically freed by the destructor.
      * data must have been allocated by the JS engine (e.g., extracted via
      * JSAutoStructuredCloneBuffer::steal).
      */
     void adopt(JSStructuredCloneData&& data, uint32_t version=JS_STRUCTURED_CLONE_VERSION,
                const JSStructuredCloneCallbacks* callbacks=nullptr, void* closure=nullptr);
--- a/js/rust/Cargo.toml
+++ b/js/rust/Cargo.toml
@@ -23,16 +23,18 @@ name = "panic"
 name = "rooting"
 [[test]]
 name = "runtime"
 [[test]]
 name = "typedarray"
 [[test]]
 name = "stack_limit"
 [[test]]
+name = "value"
+[[test]]
 name = "vec_conversion"
 
 [lib]
 doctest = false
 
 [features]
 debugmozjs = ['mozjs_sys/debugmozjs']
 promises = ['mozjs_sys/promises']
--- a/js/rust/src/jsglue.cpp
+++ b/js/rust/src/jsglue.cpp
@@ -882,45 +882,41 @@ DeleteJSAutoStructuredCloneBuffer(JSAuto
 
 size_t
 GetLengthOfJSStructuredCloneData(JSStructuredCloneData* data)
 {
     assert(data != nullptr);
 
     size_t len = 0;
 
-    auto iter = data->Iter();
-    while (!iter.Done()) {
-        size_t len_of_this_segment = iter.RemainingInSegment();
-        len += len_of_this_segment;
-        iter.Advance(*data, len_of_this_segment);
-    }
+    data->ForEachDataChunk([&](const char* bytes, size_t size) {
+        len += size;
+        return true;
+    });
 
     return len;
 }
 
 void
 CopyJSStructuredCloneData(JSStructuredCloneData* src, uint8_t* dest)
 {
     assert(src != nullptr);
     assert(dest != nullptr);
 
     size_t bytes_copied = 0;
 
-    auto iter = src->Iter();
-    while (!iter.Done()) {
-        size_t len_of_this_segment = iter.RemainingInSegment();
-        memcpy(dest + bytes_copied, iter.Data(), len_of_this_segment);
-        bytes_copied += len_of_this_segment;
-        iter.Advance(*src, len_of_this_segment);
-    }
+    src->ForEachDataChunk([&](const char* bytes, size_t size) {
+        memcpy(dest, bytes, size);
+        dest += size;
+        return true;
+    });
 }
 
 bool
 WriteBytesToJSStructuredCloneData(const uint8_t* src, size_t len, JSStructuredCloneData* dest)
 {
     assert(src != nullptr);
     assert(dest != nullptr);
 
-    return dest->WriteBytes(reinterpret_cast<const char*>(src), len);
+    return dest->AppendBytes(reinterpret_cast<const char*>(src), len);
 }
 
 } // extern "C"
--- a/js/rust/src/jsval.rs
+++ b/js/rust/src/jsval.rs
@@ -346,17 +346,17 @@ impl JS::Value {
             (self.asBits() >> 32) == ValueTag::OBJECT as u64
         }
     }
 
     #[inline(always)]
     #[cfg(target_pointer_width = "64")]
     pub fn is_symbol(&self) -> bool {
         unsafe {
-            self.asBits() == ValueShiftedTag::SYMBOL as u64
+            (self.asBits() >> JSVAL_TAG_SHIFT) == ValueTag::SYMBOL as u64
         }
     }
 
     #[inline(always)]
     #[cfg(target_pointer_width = "32")]
     pub fn is_symbol(&self) -> bool {
         unsafe {
             (self.asBits() >> 32) == ValueTag::SYMBOL as u64
new file mode 100644
--- /dev/null
+++ b/js/rust/tests/value.rs
@@ -0,0 +1,50 @@
+/* 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/. */
+
+#[macro_use]
+extern crate js;
+
+use js::jsapi::root::JS::CompartmentOptions;
+use js::jsapi::root::JS_NewGlobalObject;
+use js::jsapi::root::JS::OnNewGlobalHookOption;
+use js::jsval::UndefinedValue;
+use js::rust::{Runtime, SIMPLE_GLOBAL_CLASS};
+
+use std::ptr;
+
+#[test]
+fn is_symbol() {
+    let rt = Runtime::new(false).unwrap();
+    let cx = rt.cx();
+
+    unsafe {
+        rooted!(in(cx) let global =
+            JS_NewGlobalObject(cx, &SIMPLE_GLOBAL_CLASS, ptr::null_mut(),
+                               OnNewGlobalHookOption::FireOnNewGlobalHook,
+                               &CompartmentOptions::default())
+        );
+        rooted!(in(cx) let mut rval = UndefinedValue());
+        assert!(rt.evaluate_script(global.handle(), "Symbol('test')",
+                                   "test", 1, rval.handle_mut()).is_ok());
+        assert!(rval.is_symbol());
+    }
+}
+
+#[test]
+fn is_not_symbol() {
+    let rt = Runtime::new(false).unwrap();
+    let cx = rt.cx();
+
+    unsafe {
+        rooted!(in(cx) let global =
+            JS_NewGlobalObject(cx, &SIMPLE_GLOBAL_CLASS, ptr::null_mut(),
+                               OnNewGlobalHookOption::FireOnNewGlobalHook,
+                               &CompartmentOptions::default())
+        );
+        rooted!(in(cx) let mut rval = UndefinedValue());
+        assert!(rt.evaluate_script(global.handle(), "'not a symbol'",
+                                   "test", 1, rval.handle_mut()).is_ok());
+        assert!(!rval.is_symbol());
+    }
+}
--- a/js/src/builtin/TestingFunctions.cpp
+++ b/js/src/builtin/TestingFunctions.cpp
@@ -2828,23 +2828,23 @@ class CloneBufferObject : public NativeO
             nbytes = JS_GetStringLength(str);
         }
 
         if (nbytes == 0 || (nbytes % sizeof(uint64_t) != 0)) {
             JS_ReportErrorASCII(cx, "Invalid length for clonebuffer data");
             return false;
         }
 
-        auto buf = js::MakeUnique<JSStructuredCloneData>(0, 0, nbytes);
-        if (!buf || !buf->Init(nbytes, nbytes)) {
+        auto buf = js::MakeUnique<JSStructuredCloneData>();
+        if (!buf || !buf->Init(nbytes)) {
             ReportOutOfMemory(cx);
             return false;
         }
 
-        js_memcpy(buf->Start(), data, nbytes);
+        MOZ_ALWAYS_TRUE(buf->AppendBytes((const char*)data, nbytes));
         obj->discard();
         obj->setData(buf.release(), true);
 
         args.rval().setUndefined();
         return true;
     }
 
     static bool
@@ -2888,17 +2888,17 @@ class CloneBufferObject : public NativeO
             return false;
 
         size_t size = data->Size();
         UniqueChars buffer(static_cast<char*>(js_malloc(size)));
         if (!buffer) {
             ReportOutOfMemory(cx);
             return false;
         }
-        auto iter = data->Iter();
+        auto iter = data->Start();
         data->ReadBytes(iter, buffer.get(), size);
         JSString* str = JS_NewStringCopyN(cx, buffer.get(), size);
         if (!str)
             return false;
         args.rval().setString(str);
         return true;
     }
 
@@ -2918,17 +2918,17 @@ class CloneBufferObject : public NativeO
             return false;
 
         size_t size = data->Size();
         UniqueChars buffer(static_cast<char*>(js_malloc(size)));
         if (!buffer) {
             ReportOutOfMemory(cx);
             return false;
         }
-        auto iter = data->Iter();
+        auto iter = data->Start();
         data->ReadBytes(iter, buffer.get(), size);
         JSObject* arrayBuffer = JS_NewArrayBufferWithContents(cx, size, buffer.release());
         if (!arrayBuffer)
             return false;
         args.rval().setObject(*arrayBuffer);
         return true;
     }
 
@@ -3093,19 +3093,17 @@ Deserialize(JSContext* cx, unsigned argc
                             "(transferables already consumed?)");
         return false;
     }
 
     bool hasTransferable;
     if (!JS_StructuredCloneHasTransferables(*obj->data(), &hasTransferable))
         return false;
 
-    if (obj->isSynthetic() &&
-        (scope != JS::StructuredCloneScope::DifferentProcess || hasTransferable))
-    {
+    if (obj->isSynthetic() && scope != JS::StructuredCloneScope::DifferentProcess) {
         JS_ReportErrorASCII(cx, "clone buffer data is synthetic but may contain pointers");
         return false;
     }
 
     RootedValue deserialized(cx);
     if (!JS_ReadStructuredClone(cx, *obj->data(),
                                 JS_STRUCTURED_CLONE_VERSION,
                                 scope,
--- a/js/src/ctypes/CTypes.cpp
+++ b/js/src/ctypes/CTypes.cpp
@@ -929,17 +929,17 @@ static JSObject*
 MaybeUnwrapArrayWrapper(JSObject* obj)
 {
     if (IsProxy(obj) && obj->as<ProxyObject>().handler() == &CDataArrayProxyHandler::singleton)
         return obj->as<ProxyObject>().target();
     return obj;
 }
 
 static MOZ_ALWAYS_INLINE JSString*
-NewUCString(JSContext* cx, const AutoString& from)
+NewUCString(JSContext* cx, const AutoStringChars&& from)
 {
   return JS_NewUCStringCopyN(cx, from.begin(), from.length());
 }
 
 /*
  * Return a size rounded up to a multiple of a power of two.
  *
  * Note: |align| must be a power of 2.
@@ -977,17 +977,17 @@ GetErrorMessage(void* userRef, const uns
   if (0 < errorNumber && errorNumber < CTYPESERR_LIMIT)
     return &ErrorFormatString[errorNumber];
   return nullptr;
 }
 
 static const char*
 EncodeLatin1(JSContext* cx, AutoString& str, JSAutoByteString& bytes)
 {
-  return bytes.encodeLatin1(cx, NewUCString(cx, str));
+  return bytes.encodeLatin1(cx, NewUCString(cx, str.finish()));
 }
 
 static const char*
 CTypesToSourceForError(JSContext* cx, HandleValue val, JSAutoByteString& bytes)
 {
   if (val.isObject()) {
       RootedObject obj(cx, &val.toObject());
       if (CType::IsCType(obj) || CData::IsCDataMaybeUnwrap(&obj)) {
@@ -1009,22 +1009,22 @@ BuildCStyleTypeSource(JSContext* cx, JSO
 {
   RootedObject typeObj(cx, typeObj_);
 
   MOZ_ASSERT(CType::IsCType(typeObj));
 
   switch (CType::GetTypeCode(typeObj)) {
 #define BUILD_SOURCE(name, fromType, ffiType)                                  \
   case TYPE_##name:                                                            \
-    AppendString(source, #name);                                               \
+    AppendString(cx, source, #name);                                           \
     break;
   CTYPES_FOR_EACH_TYPE(BUILD_SOURCE)
 #undef BUILD_SOURCE
   case TYPE_void_t:
-    AppendString(source, "void");
+    AppendString(cx, source, "void");
     break;
   case TYPE_pointer: {
     unsigned ptrCount = 0;
     TypeCode type;
     RootedObject baseTypeObj(cx, typeObj);
     do {
       baseTypeObj = PointerType::GetBaseType(baseTypeObj);
       ptrCount++;
@@ -1036,18 +1036,18 @@ BuildCStyleTypeSource(JSContext* cx, JSO
       break;
     }
     BuildCStyleTypeSource(cx, baseTypeObj, source);
     AppendChars(source, '*', ptrCount);
     break;
   }
   case TYPE_struct: {
     RootedString name(cx, CType::GetName(cx, typeObj));
-    AppendString(source, "struct ");
-    AppendString(source, name);
+    AppendString(cx, source, "struct ");
+    AppendString(cx, source, name);
     break;
   }
   case TYPE_function:
     BuildCStyleFunctionTypeSource(cx, typeObj, nullptr, 0, source);
     break;
   case TYPE_array:
     MOZ_CRASH("TYPE_array shouldn't appear in function type");
   }
@@ -1057,38 +1057,38 @@ static void
 BuildCStyleFunctionTypeSource(JSContext* cx, HandleObject typeObj,
                               HandleString nameStr, unsigned ptrCount,
                               AutoString& source)
 {
   MOZ_ASSERT(CType::IsCType(typeObj));
 
   FunctionInfo* fninfo = FunctionType::GetFunctionInfo(typeObj);
   BuildCStyleTypeSource(cx, fninfo->mReturnType, source);
-  AppendString(source, " ");
+  AppendString(cx, source, " ");
   if (nameStr) {
     MOZ_ASSERT(ptrCount == 0);
-    AppendString(source, nameStr);
+    AppendString(cx, source, nameStr);
   } else if (ptrCount) {
-    AppendString(source, "(");
+    AppendString(cx, source, "(");
     AppendChars(source, '*', ptrCount);
-    AppendString(source, ")");
-  }
-  AppendString(source, "(");
+    AppendString(cx, source, ")");
+  }
+  AppendString(cx, source, "(");
   if (fninfo->mArgTypes.length() > 0) {
     for (size_t i = 0; i < fninfo->mArgTypes.length(); ++i) {
       BuildCStyleTypeSource(cx, fninfo->mArgTypes[i], source);
       if (i != fninfo->mArgTypes.length() - 1 || fninfo->mIsVariadic) {
-          AppendString(source, ", ");
+          AppendString(cx, source, ", ");
       }
     }
     if (fninfo->mIsVariadic) {
-      AppendString(source, "...");
+      AppendString(cx, source, "...");
     }
   }
-  AppendString(source, ")");
+  AppendString(cx, source, ")");
 }
 
 static void
 BuildFunctionTypeSource(JSContext* cx, HandleObject funObj, AutoString& source)
 {
   MOZ_ASSERT(CData::IsCData(funObj) || CType::IsCType(funObj));
 
   if (CData::IsCData(funObj)) {
@@ -1103,20 +1103,20 @@ BuildFunctionTypeSource(JSContext* cx, H
       return;
     }
   }
 
   RootedValue funVal(cx, ObjectValue(*funObj));
   RootedString funcStr(cx, JS_ValueToSource(cx, funVal));
   if (!funcStr) {
     JS_ClearPendingException(cx);
-    AppendString(source, "<<error converting function to string>>");
+    AppendString(cx, source, "<<error converting function to string>>");
     return;
   }
-  AppendString(source, funcStr);
+  AppendString(cx, source, funcStr);
 }
 
 enum class ConversionType {
   Argument = 0,
   Construct,
   Finalizer,
   Return,
   Setter
@@ -1126,32 +1126,32 @@ static void
 BuildConversionPosition(JSContext* cx, ConversionType convType,
                         HandleObject funObj, unsigned argIndex,
                         AutoString& source)
 {
   switch (convType) {
   case ConversionType::Argument: {
     MOZ_ASSERT(funObj);
 
-    AppendString(source, " at argument ");
+    AppendString(cx, source, " at argument ");
     AppendUInt(source, argIndex + 1);
-    AppendString(source, " of ");
+    AppendString(cx, source, " of ");
     BuildFunctionTypeSource(cx, funObj, source);
     break;
   }
   case ConversionType::Finalizer:
     MOZ_ASSERT(funObj);
 
-    AppendString(source, " at argument 1 of ");
+    AppendString(cx, source, " at argument 1 of ");
     BuildFunctionTypeSource(cx, funObj, source);
     break;
   case ConversionType::Return:
     MOZ_ASSERT(funObj);
 
-    AppendString(source, " at the return value of ");
+    AppendString(cx, source, " at the return value of ");
     BuildFunctionTypeSource(cx, funObj, source);
     break;
   default:
     MOZ_ASSERT(!funObj);
     break;
   }
 }
 
@@ -1190,16 +1190,18 @@ ConvError(JSContext* cx, const char* exp
       MOZ_ASSERT(!funObj);
 
       char indexStr[16];
       SprintfLiteral(indexStr, "%u", arrIndex);
 
       AutoString arrSource;
       JSAutoByteString arrBytes;
       BuildTypeSource(cx, arrObj, true, arrSource);
+      if (!arrSource)
+          return false;
       const char* arrStr = EncodeLatin1(cx, arrSource, arrBytes);
       if (!arrStr)
         return false;
 
       JS_ReportErrorNumberLatin1(cx, GetErrorMessage, nullptr,
                                  CTYPESMSG_CONV_ERROR_ARRAY,
                                  valStr, indexStr, arrStr);
       break;
@@ -1210,25 +1212,29 @@ ConvError(JSContext* cx, const char* exp
       JSAutoByteString nameBytes;
       const char* nameStr = nameBytes.encodeLatin1(cx, name);
       if (!nameStr)
         return false;
 
       AutoString structSource;
       JSAutoByteString structBytes;
       BuildTypeSource(cx, arrObj, true, structSource);
+      if (!structSource)
+          return false;
       const char* structStr = EncodeLatin1(cx, structSource, structBytes);
       if (!structStr)
         return false;
 
       JSAutoByteString posBytes;
       const char* posStr;
       if (funObj) {
         AutoString posSource;
         BuildConversionPosition(cx, convType, funObj, argIndex, posSource);
+        if (!posSource)
+            return false;
         posStr = EncodeLatin1(cx, posSource, posBytes);
         if (!posStr)
           return false;
       } else {
         posStr = "";
       }
 
       JS_ReportErrorNumberLatin1(cx, GetErrorMessage, nullptr,
@@ -1247,45 +1253,51 @@ ConvError(JSContext* cx, const char* exp
     MOZ_ASSERT(funObj);
 
     char indexStr[16];
     SprintfLiteral(indexStr, "%u", argIndex + 1);
 
     AutoString funSource;
     JSAutoByteString funBytes;
     BuildFunctionTypeSource(cx, funObj, funSource);
+    if (!funSource)
+        return false;
     const char* funStr = EncodeLatin1(cx, funSource, funBytes);
     if (!funStr)
       return false;
 
     JS_ReportErrorNumberLatin1(cx, GetErrorMessage, nullptr,
                                CTYPESMSG_CONV_ERROR_ARG,
                                valStr, indexStr, funStr);
     break;
   }
   case ConversionType::Finalizer: {
     MOZ_ASSERT(funObj);
 
     AutoString funSource;
     JSAutoByteString funBytes;
     BuildFunctionTypeSource(cx, funObj, funSource);
+    if (!funSource)
+        return false;
     const char* funStr = EncodeLatin1(cx, funSource, funBytes);
     if (!funStr)
       return false;
 
     JS_ReportErrorNumberLatin1(cx, GetErrorMessage, nullptr,
                                CTYPESMSG_CONV_ERROR_FIN, valStr, funStr);
     break;
   }
   case ConversionType::Return: {
     MOZ_ASSERT(funObj);
 
     AutoString funSource;
     JSAutoByteString funBytes;
     BuildFunctionTypeSource(cx, funObj, funSource);
+    if (!funSource)
+        return false;
     const char* funStr = EncodeLatin1(cx, funSource, funBytes);
     if (!funStr)
       return false;
 
     JS_ReportErrorNumberLatin1(cx, GetErrorMessage, nullptr,
                                CTYPESMSG_CONV_ERROR_RET, valStr, funStr);
     break;
   }
@@ -1307,16 +1319,18 @@ ConvError(JSContext* cx, HandleObject ex
           HandleObject funObj = nullptr, unsigned argIndex = 0,
           HandleObject arrObj = nullptr, unsigned arrIndex = 0)
 {
   MOZ_ASSERT(CType::IsCType(expectedType));
 
   AutoString expectedSource;
   JSAutoByteString expectedBytes;
   BuildTypeSource(cx, expectedType, true, expectedSource);
+  if (!expectedSource)
+      return false;
   const char* expectedStr = EncodeLatin1(cx, expectedSource, expectedBytes);
   if (!expectedStr)
     return false;
 
   return ConvError(cx, expectedStr, actual, convType, funObj, argIndex,
                    arrObj, arrIndex);
 }
 
@@ -1361,16 +1375,18 @@ ArrayLengthMismatch(JSContext* cx, unsig
   char expectedLengthStr[16];
   SprintfLiteral(expectedLengthStr, "%u", expectedLength);
   char actualLengthStr[16];
   SprintfLiteral(actualLengthStr, "%u", actualLength);
 
   AutoString arrSource;
   JSAutoByteString arrBytes;
   BuildTypeSource(cx, arrObj, true, arrSource);
+  if (!arrSource)
+      return false;
   const char* arrStr = EncodeLatin1(cx, arrSource, arrBytes);
   if (!arrStr)
     return false;
 
   JS_ReportErrorNumberLatin1(cx, GetErrorMessage, nullptr,
                              CTYPESMSG_ARRAY_MISMATCH,
                              valStr, arrStr, expectedLengthStr, actualLengthStr);
   return false;
@@ -1391,16 +1407,18 @@ ArrayLengthOverflow(JSContext* cx, unsig
   char expectedLengthStr[16];
   SprintfLiteral(expectedLengthStr, "%u", expectedLength);
   char actualLengthStr[16];
   SprintfLiteral(actualLengthStr, "%u", actualLength);
 
   AutoString arrSource;
   JSAutoByteString arrBytes;
   BuildTypeSource(cx, arrObj, true, arrSource);
+  if (!arrSource)
+      return false;
   const char* arrStr = EncodeLatin1(cx, arrSource, arrBytes);
   if (!arrStr)
     return false;
 
   JS_ReportErrorNumberLatin1(cx, GetErrorMessage, nullptr,
                              CTYPESMSG_ARRAY_OVERFLOW,
                              valStr, arrStr, expectedLengthStr, actualLengthStr);
   return false;
@@ -1456,16 +1474,18 @@ static bool
 EmptyFinalizerError(JSContext* cx, ConversionType convType,
                     HandleObject funObj = nullptr, unsigned argIndex = 0)
 {
   JSAutoByteString posBytes;
   const char* posStr;
   if (funObj) {
     AutoString posSource;
     BuildConversionPosition(cx, convType, funObj, argIndex, posSource);
+    if (!posSource)
+        return false;
     posStr = EncodeLatin1(cx, posSource, posBytes);
     if (!posStr)
       return false;
   } else {
     posStr = "";
   }
 
   JS_ReportErrorNumberLatin1(cx, GetErrorMessage, nullptr,
@@ -1485,30 +1505,34 @@ FieldCountMismatch(JSContext* cx,
   JSAutoByteString valBytes;
   const char* valStr = CTypesToSourceForError(cx, actual, valBytes);
   if (!valStr)
     return false;
 
   AutoString structSource;
   JSAutoByteString structBytes;
   BuildTypeSource(cx, structObj, true, structSource);
+  if (!structSource)
+      return false;
   const char* structStr = EncodeLatin1(cx, structSource, structBytes);
   if (!structStr)
     return false;
 
   char expectedCountStr[16];
   SprintfLiteral(expectedCountStr, "%u", expectedCount);
   char actualCountStr[16];
   SprintfLiteral(actualCountStr, "%u", actualCount);
 
   JSAutoByteString posBytes;
   const char* posStr;
   if (funObj) {
     AutoString posSource;
     BuildConversionPosition(cx, convType, funObj, argIndex, posSource);
+    if (!posSource)
+        return false;
     posStr = EncodeLatin1(cx, posSource, posBytes);
     if (!posStr)
       return false;
   } else {
     posStr = "";
   }
 
   JS_ReportErrorNumberLatin1(cx, GetErrorMessage, nullptr,
@@ -1628,16 +1652,18 @@ FinalizerSizeError(JSContext* cx, Handle
   JSAutoByteString valBytes;
   const char* valStr = CTypesToSourceForError(cx, actual, valBytes);
   if (!valStr)
     return false;
 
   AutoString funSource;
   JSAutoByteString funBytes;
   BuildFunctionTypeSource(cx, funObj, funSource);
+  if (!funSource)
+      return false;
   const char* funStr = EncodeLatin1(cx, funSource, funBytes);
   if (!funStr)
     return false;
 
   JS_ReportErrorNumberLatin1(cx, GetErrorMessage, nullptr,
                              CTYPESMSG_FIN_SIZE_ERROR, funStr, valStr);
   return false;
 }
@@ -1651,16 +1677,18 @@ FunctionArgumentLengthMismatch(JSContext
   AutoString funSource;
   JSAutoByteString funBytes;
   Value slot = JS_GetReservedSlot(funObj, SLOT_REFERENT);
   if (!slot.isUndefined() && Library::IsLibrary(&slot.toObject())) {
     BuildFunctionTypeSource(cx, funObj, funSource);
   } else {
     BuildFunctionTypeSource(cx, typeObj, funSource);
   }
+  if (!funSource)
+      return false;
   const char* funStr = EncodeLatin1(cx, funSource, funBytes);
   if (!funStr)
     return false;
 
   char expectedCountStr[16];
   SprintfLiteral(expectedCountStr, "%u", expectedCount);
   char actualCountStr[16];
   SprintfLiteral(actualCountStr, "%u", actualCount);
@@ -1804,16 +1832,18 @@ InvalidIndexRangeError(JSContext* cx, si
 static bool
 NonPrimitiveError(JSContext* cx, HandleObject typeObj)
 {
   MOZ_ASSERT(CType::IsCType(typeObj));
 
   AutoString typeSource;
   JSAutoByteString typeBytes;
   BuildTypeSource(cx, typeObj, true, typeSource);
+  if (!typeSource)
+      return false;
   const char* typeStr = EncodeLatin1(cx, typeSource, typeBytes);
   if (!typeStr)
     return false;
 
   JS_ReportErrorNumberLatin1(cx, GetErrorMessage, nullptr,
                              CTYPESMSG_NON_PRIMITIVE, typeStr);
   return false;
 }
@@ -1861,16 +1891,18 @@ PropNameNonStringError(JSContext* cx, Ha
   if (!propStr)
     return false;
 
   JSAutoByteString posBytes;
   const char* posStr;
   if (funObj) {
     AutoString posSource;
     BuildConversionPosition(cx, convType, funObj, argIndex, posSource);
+    if (!posSource)
+        return false;
     posStr = EncodeLatin1(cx, posSource, posBytes);
     if (!posStr)
       return false;
   } else {
     posStr = "";
   }
 
   JS_ReportErrorNumberLatin1(cx, GetErrorMessage, nullptr,
@@ -1913,44 +1945,47 @@ TypeOverflow(JSContext* cx, const char* 
 }
 
 static bool
 UndefinedSizeCastError(JSContext* cx, HandleObject targetTypeObj)
 {
   AutoString targetTypeSource;
   JSAutoByteString targetTypeBytes;
   BuildTypeSource(cx, targetTypeObj, true, targetTypeSource);
-  const char* targetTypeStr = EncodeLatin1(cx, targetTypeSource,
-                                           targetTypeBytes);
+  if (!targetTypeSource)
+      return false;
+  const char* targetTypeStr = EncodeLatin1(cx, targetTypeSource, targetTypeBytes);
   if (!targetTypeStr)
     return false;
 
   JS_ReportErrorNumberLatin1(cx, GetErrorMessage, nullptr,
                              CTYPESMSG_UNDEFINED_SIZE_CAST, targetTypeStr);
   return false;
 }
 
 static bool
 SizeMismatchCastError(JSContext* cx,
                       HandleObject sourceTypeObj, HandleObject targetTypeObj,
                       size_t sourceSize, size_t targetSize)
 {
   AutoString sourceTypeSource;
   JSAutoByteString sourceTypeBytes;
   BuildTypeSource(cx, sourceTypeObj, true, sourceTypeSource);
-  const char* sourceTypeStr = EncodeLatin1(cx, sourceTypeSource,
-                                           sourceTypeBytes);
+  if (!sourceTypeSource)
+      return false;
+  const char* sourceTypeStr = EncodeLatin1(cx, sourceTypeSource, sourceTypeBytes);
   if (!sourceTypeStr)
     return false;
 
   AutoString targetTypeSource;
   JSAutoByteString targetTypeBytes;
   BuildTypeSource(cx, targetTypeObj, true, targetTypeSource);
-  const char* targetTypeStr = EncodeLatin1(cx, targetTypeSource,
-                                           targetTypeBytes);
+  if (!targetTypeSource)
+      return false;
+  const char* targetTypeStr = EncodeLatin1(cx, targetTypeSource, targetTypeBytes);
   if (!targetTypeStr)
     return false;
 
   char sourceSizeStr[16];
   char targetSizeStr[16];
   SprintfLiteral(sourceSizeStr, "%zu", sourceSize);
   SprintfLiteral(targetSizeStr, "%zu", targetSize);
 
@@ -3187,19 +3222,19 @@ jsvalToPtrExplicit(JSContext* cx, Handle
       // Make sure the integer fits in the alotted precision.
       *result = uintptr_t(i);
       return uint64_t(*result) == i;
     }
   }
   return false;
 }
 
-template<class IntegerType, class CharType, size_t N, class AP>
+template<class IntegerType, class CharType, size_t N>
 void
-IntegerToString(IntegerType i, int radix, mozilla::Vector<CharType, N, AP>& result)
+IntegerToString(IntegerType i, int radix, StringBuilder<CharType, N>& result)
 {
   JS_STATIC_ASSERT(numeric_limits<IntegerType>::is_exact);
 
   // The buffer must be big enough for all the bits of IntegerType to fit,
   // in base-2, including '-'.
   CharType buffer[sizeof(IntegerType) * 8 + 1];
   CharType* end = buffer + sizeof(buffer) / sizeof(CharType);
   CharType* cp = end;
@@ -3984,79 +4019,79 @@ BuildTypeName(JSContext* cx, JSObject* t
   // of the rules for building C type declarations can be found at:
   // http://unixwiz.net/techtips/reading-cdecl.html
   TypeCode prevGrouping = CType::GetTypeCode(typeObj), currentGrouping;
   while (true) {
     currentGrouping = CType::GetTypeCode(typeObj);
     switch (currentGrouping) {
     case TYPE_pointer: {
       // Pointer types go on the left.
-      PrependString(result, "*");
+      PrependString(cx, result, "*");
 
       typeObj = PointerType::GetBaseType(typeObj);
       prevGrouping = currentGrouping;
       continue;
     }
     case TYPE_array: {
       if (prevGrouping == TYPE_pointer) {
         // Outer type is pointer, inner type is array. Grouping is required.
-        PrependString(result, "(");
-        AppendString(result, ")");
+        PrependString(cx, result, "(");
+        AppendString(cx, result, ")");
       }
 
       // Array types go on the right.
-      AppendString(result, "[");
+      AppendString(cx, result, "[");
       size_t length;
       if (ArrayType::GetSafeLength(typeObj, &length))
         IntegerToString(length, 10, result);
 
-      AppendString(result, "]");
+      AppendString(cx, result, "]");
 
       typeObj = ArrayType::GetBaseType(typeObj);
       prevGrouping = currentGrouping;
       continue;
     }
     case TYPE_function: {
       FunctionInfo* fninfo = FunctionType::GetFunctionInfo(typeObj);
 
       // Add in the calling convention, if it's not cdecl.
       // There's no trailing or leading space needed here, as none of the
       // modifiers can produce a string beginning with an identifier ---
       // except for TYPE_function itself, which is fine because functions
       // can't return functions.
       ABICode abi = GetABICode(fninfo->mABI);
       if (abi == ABI_STDCALL)
-        PrependString(result, "__stdcall");
+        PrependString(cx, result, "__stdcall");
       else if (abi == ABI_THISCALL)
-        PrependString(result, "__thiscall");
+        PrependString(cx, result, "__thiscall");
       else if (abi == ABI_WINAPI)
-        PrependString(result, "WINAPI");
+        PrependString(cx, result, "WINAPI");
 
       // Function application binds more tightly than dereferencing, so
       // wrap pointer types in parens. Functions can't return functions
       // (only pointers to them), and arrays can't hold functions
       // (similarly), so we don't need to address those cases.
       if (prevGrouping == TYPE_pointer) {
-        PrependString(result, "(");
-        AppendString(result, ")");
+        PrependString(cx, result, "(");
+        AppendString(cx, result, ")");
       }
 
       // Argument list goes on the right.
-      AppendString(result, "(");
+      AppendString(cx, result, "(");
       for (size_t i = 0; i < fninfo->mArgTypes.length(); ++i) {
         RootedObject argType(cx, fninfo->mArgTypes[i]);
         JSString* argName = CType::GetName(cx, argType);
-        AppendString(result, argName);
+        AppendString(cx, result, argName);
         if (i != fninfo->mArgTypes.length() - 1 ||
             fninfo->mIsVariadic)
-          AppendString(result, ", ");
+          AppendString(cx, result, ", ");
       }
       if (fninfo->mIsVariadic)
-        AppendString(result, "...");
-      AppendString(result, ")");
+        AppendString(cx, result, "...");
+      AppendString(cx, result, ")");
 
       // Set 'typeObj' to the return type, and let the loop process it.
       // 'prevGrouping' doesn't matter here, because functions cannot return
       // arrays -- thus the parenthetical rules don't get tickled.
       typeObj = fninfo->mReturnType;
       continue;
     }
     default:
@@ -4064,213 +4099,215 @@ BuildTypeName(JSContext* cx, JSObject* t
       break;
     }
     break;
   }
 
   // If prepending the base type name directly would splice two
   // identifiers, insert a space.
   if (IsAsciiAlpha(result[0]) || result[0] == '_')
-    PrependString(result, " ");
+    PrependString(cx, result, " ");
 
   // Stick the base type and derived type parts together.
   JSString* baseName = CType::GetName(cx, typeObj);
-  PrependString(result, baseName);
-  return NewUCString(cx, result);
+  PrependString(cx, result, baseName);
+  if (!result)
+      return nullptr;
+  return NewUCString(cx, result.finish());
 }
 
 // Given a CType 'typeObj', generate a string 'result' such that 'eval(result)'
 // would construct the same CType. If 'makeShort' is true, assume that any
 // StructType 't' is bound to an in-scope variable of name 't.name', and use
 // that variable in place of generating a string to construct the type 't'.
 // (This means the type comparison function CType::TypesEqual will return true
-// when comparing the input and output of BuildTypeSource, since struct
+// when comparing the input and output of AppendTypeSource, since struct
 // equality is determined by strict JSObject pointer equality.)
 static void
 BuildTypeSource(JSContext* cx,
                 JSObject* typeObj_,
                 bool makeShort,
                 AutoString& result)
 {
   RootedObject typeObj(cx, typeObj_);
 
   // Walk the types, building up the toSource() string.
   switch (CType::GetTypeCode(typeObj)) {
   case TYPE_void_t:
 #define CASE_FOR_TYPE(name, type, ffiType)  case TYPE_##name:
   CTYPES_FOR_EACH_TYPE(CASE_FOR_TYPE)
 #undef CASE_FOR_TYPE
   {
-    AppendString(result, "ctypes.");
+    AppendString(cx, result, "ctypes.");
     JSString* nameStr = CType::GetName(cx, typeObj);
-    AppendString(result, nameStr);
+    AppendString(cx, result, nameStr);
     break;
   }
   case TYPE_pointer: {
     RootedObject baseType(cx, PointerType::GetBaseType(typeObj));
 
     // Specialcase ctypes.voidptr_t.
     if (CType::GetTypeCode(baseType) == TYPE_void_t) {
-      AppendString(result, "ctypes.voidptr_t");
+      AppendString(cx, result, "ctypes.voidptr_t");
       break;
     }
 
     // Recursively build the source string, and append '.ptr'.
     BuildTypeSource(cx, baseType, makeShort, result);
-    AppendString(result, ".ptr");
+    AppendString(cx, result, ".ptr");
     break;
   }
   case TYPE_function: {
     FunctionInfo* fninfo = FunctionType::GetFunctionInfo(typeObj);
 
-    AppendString(result, "ctypes.FunctionType(");
+    AppendString(cx, result, "ctypes.FunctionType(");
 
     switch (GetABICode(fninfo->mABI)) {
     case ABI_DEFAULT:
-      AppendString(result, "ctypes.default_abi, ");
+      AppendString(cx, result, "ctypes.default_abi, ");
       break;
     case ABI_STDCALL:
-      AppendString(result, "ctypes.stdcall_abi, ");
+      AppendString(cx, result, "ctypes.stdcall_abi, ");
       break;
     case ABI_THISCALL:
-      AppendString(result, "ctypes.thiscall_abi, ");
+      AppendString(cx, result, "ctypes.thiscall_abi, ");
       break;
     case ABI_WINAPI:
-      AppendString(result, "ctypes.winapi_abi, ");
+      AppendString(cx, result, "ctypes.winapi_abi, ");
       break;
     case INVALID_ABI:
       MOZ_CRASH("invalid abi");
     }
 
     // Recursively build the source string describing the function return and
     // argument types.
     BuildTypeSource(cx, fninfo->mReturnType, true, result);
 
     if (fninfo->mArgTypes.length() > 0) {
-      AppendString(result, ", [");
+      AppendString(cx, result, ", [");
       for (size_t i = 0; i < fninfo->mArgTypes.length(); ++i) {
         BuildTypeSource(cx, fninfo->mArgTypes[i], true, result);
         if (i != fninfo->mArgTypes.length() - 1 ||
             fninfo->mIsVariadic)
-          AppendString(result, ", ");
+          AppendString(cx, result, ", ");
       }
       if (fninfo->mIsVariadic)
-        AppendString(result, "\"...\"");
-      AppendString(result, "]");
+        AppendString(cx, result, "\"...\"");
+      AppendString(cx, result, "]");
     }
 
-    AppendString(result, ")");
+    AppendString(cx, result, ")");
     break;
   }
   case TYPE_array: {
     // Recursively build the source string, and append '.array(n)',
     // where n is the array length, or the empty string if the array length
     // is undefined.
     JSObject* baseType = ArrayType::GetBaseType(typeObj);
     BuildTypeSource(cx, baseType, makeShort, result);
-    AppendString(result, ".array(");
+    AppendString(cx, result, ".array(");
 
     size_t length;
     if (ArrayType::GetSafeLength(typeObj, &length))
       IntegerToString(length, 10, result);
 
-    AppendString(result, ")");
+    AppendString(cx, result, ")");
     break;
   }
   case TYPE_struct: {
     JSString* name = CType::GetName(cx, typeObj);
 
     if (makeShort) {
       // Shorten the type declaration by assuming that StructType 't' is bound
       // to an in-scope variable of name 't.name'.
-      AppendString(result, name);
+      AppendString(cx, result, name);
       break;
     }
 
     // Write the full struct declaration.
-    AppendString(result, "ctypes.StructType(\"");
-    AppendString(result, name);
-    AppendString(result, "\"");
+    AppendString(cx, result, "ctypes.StructType(\"");
+    AppendString(cx, result, name);
+    AppendString(cx, result, "\"");
 
     // If it's an opaque struct, we're done.
     if (!CType::IsSizeDefined(typeObj)) {
-      AppendString(result, ")");
+      AppendString(cx, result, ")");
       break;
     }
 
-    AppendString(result, ", [");
+    AppendString(cx, result, ", [");
 
     const FieldInfoHash* fields = StructType::GetFieldInfo(typeObj);
     size_t length = fields->count();
     Vector<const FieldInfoHash::Entry*, 64, SystemAllocPolicy> fieldsArray;
     if (!fieldsArray.resize(length))
       break;
 
     for (FieldInfoHash::Range r = fields->all(); !r.empty(); r.popFront())
       fieldsArray[r.front().value().mIndex] = &r.front();
 
     for (size_t i = 0; i < length; ++i) {
       const FieldInfoHash::Entry* entry = fieldsArray[i];
-      AppendString(result, "{ \"");
-      AppendString(result, entry->key());
-      AppendString(result, "\": ");
+      AppendString(cx, result, "{ \"");
+      AppendString(cx, result, entry->key());
+      AppendString(cx, result, "\": ");
       BuildTypeSource(cx, entry->value().mType, true, result);
-      AppendString(result, " }");
+      AppendString(cx, result, " }");
       if (i != length - 1)
-        AppendString(result, ", ");
+        AppendString(cx, result, ", ");
     }
 
-    AppendString(result, "])");
+    AppendString(cx, result, "])");
     break;
   }
   }
 }
 
 // Given a CData object of CType 'typeObj' with binary value 'data', generate a
 // string 'result' such that 'eval(result)' would construct a CData object with
 // the same CType and containing the same binary value. This assumes that any
 // StructType 't' is bound to an in-scope variable of name 't.name'. (This means
 // the type comparison function CType::TypesEqual will return true when
 // comparing the types, since struct equality is determined by strict JSObject
 // pointer equality.) Further, if 'isImplicit' is true, ensure that the
 // resulting string can ImplicitConvert successfully if passed to another data
 // constructor. (This is important when called recursively, since fields of
 // structs and arrays are converted with ImplicitConvert.)
-static bool
+static MOZ_MUST_USE bool
 BuildDataSource(JSContext* cx,
                 HandleObject typeObj,
                 void* data,
                 bool isImplicit,
                 AutoString& result)
 {
   TypeCode type = CType::GetTypeCode(typeObj);
   switch (type) {
   case TYPE_bool:
     if (*static_cast<bool*>(data))
-      AppendString(result, "true");
+      AppendString(cx, result, "true");
     else
-      AppendString(result, "false");
+      AppendString(cx, result, "false");
     break;
 #define INTEGRAL_CASE(name, type, ffiType)                                     \
   case TYPE_##name:                                                            \
     /* Serialize as a primitive decimal integer. */                            \
     IntegerToString(*static_cast<type*>(data), 10, result);                    \
     break;
   CTYPES_FOR_EACH_INT_TYPE(INTEGRAL_CASE)
 #undef INTEGRAL_CASE
 #define WRAPPED_INT_CASE(name, type, ffiType)                                  \
   case TYPE_##name:                                                            \
     /* Serialize as a wrapped decimal integer. */                              \
     if (!numeric_limits<type>::is_signed)                                      \
-      AppendString(result, "ctypes.UInt64(\"");                                \
+      AppendString(cx, result, "ctypes.UInt64(\"");                            \
     else                                                                       \
-      AppendString(result, "ctypes.Int64(\"");                                 \
+      AppendString(cx, result, "ctypes.Int64(\"");                             \
                                                                                \
     IntegerToString(*static_cast<type*>(data), 10, result);                    \
-    AppendString(result, "\")");                                               \
+    AppendString(cx, result, "\")");                                           \
     break;
   CTYPES_FOR_EACH_WRAPPED_INT_TYPE(WRAPPED_INT_CASE)
 #undef WRAPPED_INT_CASE
 #define FLOAT_CASE(name, type, ffiType)                                        \
   case TYPE_##name: {                                                          \
     /* Serialize as a primitive double. */                                     \
     double fp = *static_cast<type*>(data);                                     \
     ToCStringBuf cbuf;                                                         \
@@ -4297,64 +4334,64 @@ BuildDataSource(JSContext* cx,
       return false;
 
     // Escape characters, and quote as necessary.
     RootedValue valStr(cx, StringValue(str));
     JSString* src = JS_ValueToSource(cx, valStr);
     if (!src)
       return false;
 
-    AppendString(result, src);
+    AppendString(cx, result, src);
     break;
   }
   case TYPE_pointer:
   case TYPE_function: {
     if (isImplicit) {
       // The result must be able to ImplicitConvert successfully.
       // Wrap in a type constructor, then serialize for ExplicitConvert.
       BuildTypeSource(cx, typeObj, true, result);
-      AppendString(result, "(");
+      AppendString(cx, result, "(");
     }
 
     // Serialize the pointer value as a wrapped hexadecimal integer.
     uintptr_t ptr = *static_cast<uintptr_t*>(data);
-    AppendString(result, "ctypes.UInt64(\"0x");
+    AppendString(cx, result, "ctypes.UInt64(\"0x");
     IntegerToString(ptr, 16, result);
-    AppendString(result, "\")");
+    AppendString(cx, result, "\")");
 
     if (isImplicit)
-      AppendString(result, ")");
+      AppendString(cx, result, ")");
 
     break;
   }
   case TYPE_array: {
     // Serialize each element of the array recursively. Each element must
     // be able to ImplicitConvert successfully.
     RootedObject baseType(cx, ArrayType::GetBaseType(typeObj));
-    AppendString(result, "[");
+    AppendString(cx, result, "[");
 
     size_t length = ArrayType::GetLength(typeObj);
     size_t elementSize = CType::GetSize(baseType);
     for (size_t i = 0; i < length; ++i) {
       char* element = static_cast<char*>(data) + elementSize * i;
       if (!BuildDataSource(cx, baseType, element, true, result))
         return false;
 
       if (i + 1 < length)
-        AppendString(result, ", ");
+        AppendString(cx, result, ", ");
     }
-    AppendString(result, "]");
+    AppendString(cx, result, "]");
     break;
   }
   case TYPE_struct: {
     if (isImplicit) {
       // The result must be able to ImplicitConvert successfully.
       // Serialize the data as an object with properties, rather than
       // a sequence of arguments to the StructType constructor.
-      AppendString(result, "{");
+      AppendString(cx, result, "{");
     }
 
     // Serialize each field of the struct recursively. Each field must
     // be able to ImplicitConvert successfully.
     const FieldInfoHash* fields = StructType::GetFieldInfo(typeObj);
     size_t length = fields->count();
     Vector<const FieldInfoHash::Entry*, 64, SystemAllocPolicy> fieldsArray;
     if (!fieldsArray.resize(length))
@@ -4362,32 +4399,32 @@ BuildDataSource(JSContext* cx,
 
     for (FieldInfoHash::Range r = fields->all(); !r.empty(); r.popFront())
       fieldsArray[r.front().value().mIndex] = &r.front();
 
     for (size_t i = 0; i < length; ++i) {
       const FieldInfoHash::Entry* entry = fieldsArray[i];
 
       if (isImplicit) {
-        AppendString(result, "\"");
-        AppendString(result, entry->key());
-        AppendString(result, "\": ");
+        AppendString(cx, result, "\"");
+        AppendString(cx, result, entry->key());
+        AppendString(cx, result, "\": ");
       }
 
       char* fieldData = static_cast<char*>(data) + entry->value().mOffset;
       RootedObject entryType(cx, entry->value().mType);
       if (!BuildDataSource(cx, entryType, fieldData, true, result))
         return false;
 
       if (i + 1 != length)
-        AppendString(result, ", ");
+        AppendString(cx, result, ", ");
     }
 
     if (isImplicit)
-      AppendString(result, "}");
+      AppendString(cx, result, "}");
 
     break;
   }
   case TYPE_void_t:
     MOZ_CRASH("invalid type");
   }
 
   return true;
@@ -4992,19 +5029,21 @@ CType::ToString(JSContext* cx, unsigned 
                                  InformalValueTypeName(args.thisv()));
   }
 
   // Create the appropriate string depending on whether we're sCTypeClass or
   // sCTypeProtoClass.
   JSString* result;
   if (CType::IsCType(obj)) {
     AutoString type;
-    AppendString(type, "type ");
-    AppendString(type, GetName(cx, obj));
-    result = NewUCString(cx, type);
+    AppendString(cx, type, "type ");
+    AppendString(cx, type, GetName(cx, obj));
+    if (!type)
+        return false;
+    result = NewUCString(cx, type.finish());
   }
   else {
     result = JS_NewStringCopyZ(cx, "[CType proto object]");
   }
   if (!result)
     return false;
 
   args.rval().setString(result);
@@ -5024,17 +5063,19 @@ CType::ToSource(JSContext* cx, unsigned 
   }
 
   // Create the appropriate string depending on whether we're sCTypeClass or
   // sCTypeProtoClass.
   JSString* result;
   if (CType::IsCType(obj)) {
     AutoString source;
     BuildTypeSource(cx, obj, false, source);
-    result = NewUCString(cx, source);
+    if (!source)
+        return false;
+    result = NewUCString(cx, source.finish());
   } else {
     result = JS_NewStringCopyZ(cx, "[CType proto object]");
   }
   if (!result)
     return false;
 
   args.rval().setString(result);
   return true;
@@ -6800,52 +6841,53 @@ PrepareCIF(JSContext* cx,
     return false;
   default:
     JS_ReportErrorASCII(cx, "Unknown libffi error");
     return false;
   }
 }
 
 void
-FunctionType::BuildSymbolName(JSString* name,
+FunctionType::BuildSymbolName(JSContext* cx,
+                              JSString* name,
                               JSObject* typeObj,
                               AutoCString& result)
 {
   FunctionInfo* fninfo = GetFunctionInfo(typeObj);
 
   switch (GetABICode(fninfo->mABI)) {
   case ABI_DEFAULT:
   case ABI_THISCALL:
   case ABI_WINAPI:
     // For cdecl or WINAPI functions, no mangling is necessary.
-    AppendString(result, name);
+    AppendString(cx, result, name);
     break;
 
   case ABI_STDCALL: {
 #if (defined(_WIN32) && !defined(_WIN64)) || defined(_OS2)
     // On WIN32, stdcall functions look like:
     //   _foo@40
     // where 'foo' is the function name, and '40' is the aligned size of the
     // arguments.
-    AppendString(result, "_");
-    AppendString(result, name);
-    AppendString(result, "@");
+    AppendString(cx, result, "_");
+    AppendString(cx, result, name);
+    AppendString(cx, result, "@");
 
     // Compute the suffix by aligning each argument to sizeof(ffi_arg).
     size_t size = 0;
     for (size_t i = 0; i < fninfo->mArgTypes.length(); ++i) {
       JSObject* argType = fninfo->mArgTypes[i];
       size += Align(CType::GetSize(argType), sizeof(ffi_arg));
     }
 
     IntegerToString(size, 10, result);
 #elif defined(_WIN64)
     // On Win64, stdcall is an alias to the default ABI for compatibility, so no
     // mangling is done.
-    AppendString(result, name);
+    AppendString(cx, result, name);
 #endif
     break;
   }
 
   case INVALID_ABI:
     MOZ_CRASH("invalid abi");
   }
 }
@@ -8054,23 +8096,24 @@ CData::GetSourceString(JSContext* cx, Ha
   // Walk the types, building up the toSource() string.
   // First, we build up the type expression:
   // 't.ptr' for pointers;
   // 't.array([n])' for arrays;
   // 'n' for structs, where n = t.name, the struct's name. (We assume this is
   // bound to a variable in the current scope.)
   AutoString source;
   BuildTypeSource(cx, typeObj, true, source);
-  AppendString(source, "(");
+  AppendString(cx, source, "(");
   if (!BuildDataSource(cx, typeObj, data, false, source))
+    source.handle(false);
+  AppendString(cx, source, ")");
+  if (!source)
     return nullptr;
 
-  AppendString(source, ")");
-
-  return NewUCString(cx, source);
+  return NewUCString(cx, source.finish());
 }
 
 bool
 CData::ToSource(JSContext* cx, unsigned argc, Value* vp)
 {
   CallArgs args = CallArgsFromVp(argc, vp);
   if (args.length() != 0) {
     return ArgumentLengthError(cx, "CData.prototype.toSource", "no", "s");
@@ -8138,38 +8181,40 @@ CDataFinalizer::Methods::ToSource(JSCont
   } else {
     RootedObject objType(cx, CDataFinalizer::GetCType(cx, objThis));
     if (!objType) {
       JS_ReportErrorASCII(cx, "CDataFinalizer has no type");
       return false;
     }
 
     AutoString source;
-    AppendString(source, "ctypes.CDataFinalizer(");
+    AppendString(cx, source, "ctypes.CDataFinalizer(");
     JSString* srcValue = CData::GetSourceString(cx, objType, p->cargs);
     if (!srcValue) {
       return false;
     }
-    AppendString(source, srcValue);
-    AppendString(source, ", ");
+    AppendString(cx, source, srcValue);
+    AppendString(cx, source, ", ");
     Value valCodePtrType = JS_GetReservedSlot(objThis,
                                               SLOT_DATAFINALIZER_CODETYPE);
     if (valCodePtrType.isPrimitive()) {
       return false;
     }
 
     RootedObject typeObj(cx, valCodePtrType.toObjectOrNull());
     JSString* srcDispose = CData::GetSourceString(cx, typeObj, &(p->code));
     if (!srcDispose) {
       return false;
     }
 
-    AppendString(source, srcDispose);
-    AppendString(source, ")");
-    strMessage = NewUCString(cx, source);
+    AppendString(cx, source, srcDispose);
+    AppendString(cx, source, ")");
+    if (!source)
+        return false;
+    strMessage = NewUCString(cx, source.finish());
   }
 
   if (!strMessage) {
     // This is a memory issue, no error message
     return false;
   }
 
   args.rval().setString(strMessage);
@@ -8739,17 +8784,19 @@ Int64Base::ToString(JSContext* cx,
 
   AutoString intString;
   if (isUnsigned) {
     IntegerToString(GetInt(obj), radix, intString);
   } else {
     IntegerToString(static_cast<int64_t>(GetInt(obj)), radix, intString);
   }
 
-  JSString* result = NewUCString(cx, intString);
+  if (!intString)
+      return false;
+  JSString* result = NewUCString(cx, intString.finish());
   if (!result)
     return false;
 
   args.rval().setString(result);
   return true;
 }
 
 bool
@@ -8763,25 +8810,27 @@ Int64Base::ToSource(JSContext* cx,
       return ArgumentLengthError(cx, "UInt64.prototype.toSource", "no", "s");
     }
     return ArgumentLengthError(cx, "Int64.prototype.toSource", "no", "s");
   }
 
   // Return a decimal string suitable for constructing the number.
   AutoString source;
   if (isUnsigned) {
-    AppendString(source, "ctypes.UInt64(\"");
+    AppendString(cx, source, "ctypes.UInt64(\"");
     IntegerToString(GetInt(obj), 10, source);
   } else {
-    AppendString(source, "ctypes.Int64(\"");
+    AppendString(cx, source, "ctypes.Int64(\"");
     IntegerToString(static_cast<int64_t>(GetInt(obj)), 10, source);
   }
-  AppendString(source, "\")");
-
-  JSString* result = NewUCString(cx, source);
+  AppendString(cx, source, "\")");
+  if (!source)
+    return false;
+
+  JSString* result = NewUCString(cx, source.finish());
   if (!result)
     return false;
 
   args.rval().setString(result);
   return true;
 }
 
 bool
--- a/js/src/ctypes/CTypes.h
+++ b/js/src/ctypes/CTypes.h
@@ -21,144 +21,223 @@
 
 namespace js {
 namespace ctypes {
 
 /*******************************************************************************
 ** Utility classes
 *******************************************************************************/
 
-// String and AutoString classes, based on Vector.
-typedef Vector<char16_t,  0, SystemAllocPolicy> String;
-typedef Vector<char16_t, 64, SystemAllocPolicy> AutoString;
-typedef Vector<char,      0, SystemAllocPolicy> CString;
-typedef Vector<char,     64, SystemAllocPolicy> AutoCString;
+// CTypes builds a number of strings. StringBuilder allows repeated appending
+// with a single error check at the end. Only the Vector methods required for
+// building the string are exposed.
+
+template <class CharT, size_t N>
+class StringBuilder {
+  Vector<CharT, N, SystemAllocPolicy> v;
+
+  // Have any (OOM) errors been encountered while constructing this string?
+  bool errored { false };
+
+#ifdef DEBUG
+  // Have we finished building this string?
+  bool finished { false };
+
+  // Did we check for errors?
+  mutable bool checked { false };
+#endif
+
+ public:
+
+  explicit operator bool() const {
+#ifdef DEBUG
+    checked = true;
+#endif
+    return !errored;
+  }
+
+  // Handle the result of modifying the string, by remembering the persistent
+  // errored status.
+  bool handle(bool result) {
+    MOZ_ASSERT(!finished);
+    if (!result)
+      errored = true;
+    return result;
+  }
+
+  bool resize(size_t n) {
+    return handle(v.resize(n));
+  }
+
+  CharT& operator[](size_t index) { return v[index]; }
+  const CharT& operator[](size_t index) const { return v[index]; }
+  size_t length() const { return v.length(); }
+
+  template<typename U> MOZ_MUST_USE bool append(U&& u) {
+    return handle(v.append(u));
+  }
+
+  template<typename U> MOZ_MUST_USE bool append(const U* begin, const U* end) {
+    return handle(v.append(begin, end));
+  }
+
+  template<typename U> MOZ_MUST_USE bool append(const U* begin, size_t len) {
+    return handle(v.append(begin, len));
+  }
+
+  CharT* begin() {
+    MOZ_ASSERT(!finished);
+    return v.begin();
+  }
+
+  // finish() produces the results of the string building, and is required as
+  // the last thing before the string contents are used. The StringBuilder must
+  // be checked for errors before calling this, however.
+  Vector<CharT, N, SystemAllocPolicy>&& finish() {
+    MOZ_ASSERT(!errored);
+    MOZ_ASSERT(!finished);
+    MOZ_ASSERT(checked);
+#ifdef DEBUG
+    finished = true;
+#endif
+    return mozilla::Move(v);
+  }
+};
+
+// Note that these strings do not have any inline storage, because we use move
+// constructors to pass the data around and inline storage would necessitate
+// copying.
+typedef StringBuilder<char16_t, 0> AutoString;
+typedef StringBuilder<char,     0> AutoCString;
+
+typedef Vector<char16_t, 0, SystemAllocPolicy> AutoStringChars;
+typedef Vector<char,     0, SystemAllocPolicy> AutoCStringChars;
 
 // Convenience functions to append, insert, and compare Strings.
-template <class T, size_t N, class AP, size_t ArrayLength>
+template <class T, size_t N, size_t ArrayLength>
 void
-AppendString(mozilla::Vector<T, N, AP>& v, const char (&array)[ArrayLength])
+AppendString(JSContext* cx, StringBuilder<T, N>& v, const char (&array)[ArrayLength])
 {
   // Don't include the trailing '\0'.
   size_t alen = ArrayLength - 1;
   size_t vlen = v.length();
   if (!v.resize(vlen + alen))
     return;
 
   for (size_t i = 0; i < alen; ++i)
     v[i + vlen] = array[i];
 }
 
-template <class T, size_t N, class AP>
+template <class T, size_t N>
 void
-AppendChars(mozilla::Vector<T, N, AP>& v, const char c, size_t count)
+AppendChars(StringBuilder<T, N>& v, const char c, size_t count)
 {
   size_t vlen = v.length();
   if (!v.resize(vlen + count))
     return;
 
   for (size_t i = 0; i < count; ++i)
     v[i + vlen] = c;
 }
 
-template <class T, size_t N, class AP>
+template <class T, size_t N>
 void
-AppendUInt(mozilla::Vector<T, N, AP>& v, unsigned n)
+AppendUInt(StringBuilder<T, N>& v, unsigned n)
 {
   char array[16];
   size_t alen = SprintfLiteral(array, "%u", n);
   size_t vlen = v.length();
   if (!v.resize(vlen + alen))
     return;
 
   for (size_t i = 0; i < alen; ++i)
     v[i + vlen] = array[i];
 }
 
 template <class T, size_t N, size_t M, class AP>
 void
-AppendString(mozilla::Vector<T, N, AP>& v, mozilla::Vector<T, M, AP>& w)
+AppendString(JSContext* cx, StringBuilder<T, N>& v, mozilla::Vector<T, M, AP>& w)
 {
   if (!v.append(w.begin(), w.length()))
     return;
 }
 
-template <size_t N, class AP>
+template <size_t N>
 void
-AppendString(mozilla::Vector<char16_t, N, AP>& v, JSString* str)
+AppendString(JSContext* cx, StringBuilder<char16_t, N>& v, JSString* str)
 {
   MOZ_ASSERT(str);
-  JSLinearString* linear = str->ensureLinear(nullptr);
+  JSLinearString* linear = str->ensureLinear(cx);
   if (!linear)
     return;
   JS::AutoCheckCannotGC nogc;
   if (linear->hasLatin1Chars()) {
     if (!v.append(linear->latin1Chars(nogc), linear->length()))
       return;
   } else {
     if (!v.append(linear->twoByteChars(nogc), linear->length()))
       return;
   }
 }
 
-template <size_t N, class AP>
+template <size_t N>
 void
-AppendString(mozilla::Vector<char, N, AP>& v, JSString* str)
+AppendString(JSContext* cx, StringBuilder<char, N>& v, JSString* str)
 {
   MOZ_ASSERT(str);
   size_t vlen = v.length();
   size_t alen = str->length();
   if (!v.resize(vlen + alen))
     return;
 
-  JSLinearString* linear = str->ensureLinear(nullptr);
+  JSLinearString* linear = str->ensureLinear(cx);
   if (!linear)
     return;
 
   JS::AutoCheckCannotGC nogc;
   if (linear->hasLatin1Chars()) {
     const Latin1Char* chars = linear->latin1Chars(nogc);
     for (size_t i = 0; i < alen; ++i)
       v[i + vlen] = char(chars[i]);
   } else {
     const char16_t* chars = linear->twoByteChars(nogc);
     for (size_t i = 0; i < alen; ++i)
       v[i + vlen] = char(chars[i]);
   }
 }
 
-template <class T, size_t N, class AP, size_t ArrayLength>
+template <class T, size_t N, size_t ArrayLength>
 void
-PrependString(mozilla::Vector<T, N, AP>& v, const char (&array)[ArrayLength])
+PrependString(JSContext* cx, StringBuilder<T, N>& v, const char (&array)[ArrayLength])
 {
   // Don't include the trailing '\0'.
   size_t alen = ArrayLength - 1;
   size_t vlen = v.length();
   if (!v.resize(vlen + alen))
     return;
 
   // Move vector data forward. This is safe since we've already resized.
   memmove(v.begin() + alen, v.begin(), vlen * sizeof(T));
 
   // Copy data to insert.
   for (size_t i = 0; i < alen; ++i)
     v[i] = array[i];
 }
 
-template <size_t N, class AP>
+template <size_t N>
 void
-PrependString(mozilla::Vector<char16_t, N, AP>& v, JSString* str)
+PrependString(JSContext* cx, StringBuilder<char16_t, N>& v, JSString* str)
 {
   MOZ_ASSERT(str);
   size_t vlen = v.length();
   size_t alen = str->length();
   if (!v.resize(vlen + alen))
     return;
 
-  JSLinearString* linear = str->ensureLinear(nullptr);
+  JSLinearString* linear = str->ensureLinear(cx);
   if (!linear)
     return;
 
   // Move vector data forward. This is safe since we've already resized.
   memmove(v.begin() + alen, v.begin(), vlen * sizeof(char16_t));
 
   // Copy data to insert.
   JS::AutoCheckCannotGC nogc;
@@ -497,17 +576,17 @@ namespace StructType {
 namespace FunctionType {
   JSObject* CreateInternal(JSContext* cx, HandleValue abi, HandleValue rtype,
     const HandleValueArray& args);
 
   JSObject* ConstructWithObject(JSContext* cx, JSObject* typeObj,
     JSObject* refObj, PRFuncPtr fnptr, JSObject* result);
 
   FunctionInfo* GetFunctionInfo(JSObject* obj);
-  void BuildSymbolName(JSString* name, JSObject* typeObj,
+  void BuildSymbolName(JSContext* cx, JSString* name, JSObject* typeObj,
     AutoCString& result);
 } // namespace FunctionType
 
 namespace CClosure {
   JSObject* Create(JSContext* cx, HandleObject typeObj, HandleObject fnObj,
     HandleObject thisObj, HandleValue errVal, PRFuncPtr* fnptr);
 } // namespace CClosure
 
--- a/js/src/ctypes/Library.cpp
+++ b/js/src/ctypes/Library.cpp
@@ -67,22 +67,24 @@ Library::Name(JSContext* cx, unsigned ar
   if (arg.isString()) {
     str = arg.toString();
   } else {
     JS_ReportErrorASCII(cx, "name argument must be a string");
     return false;
   }
 
   AutoString resultString;
-  AppendString(resultString, DLL_PREFIX);
-  AppendString(resultString, str);
-  AppendString(resultString, DLL_SUFFIX);
+  AppendString(cx, resultString, DLL_PREFIX);
+  AppendString(cx, resultString, str);
+  AppendString(cx, resultString, DLL_SUFFIX);
+  if (!resultString)
+    return false;
+  auto resultStr = resultString.finish();
 
-  JSString* result = JS_NewUCStringCopyN(cx, resultString.begin(),
-                                         resultString.length());
+  JSString* result = JS_NewUCStringCopyN(cx, resultStr.begin(), resultStr.length());
   if (!result)
     return false;
 
   args.rval().setString(result);
   return true;
 }
 
 JSObject*
@@ -334,33 +336,37 @@ Library::Declare(JSContext* cx, unsigned
   }
 
   void* data;
   PRFuncPtr fnptr;
   RootedString nameStr(cx, args[0].toString());
   AutoCString symbol;
   if (isFunction) {
     // Build the symbol, with mangling if necessary.
-    FunctionType::BuildSymbolName(nameStr, fnObj, symbol);
-    AppendString(symbol, "\0");
+    FunctionType::BuildSymbolName(cx, nameStr, fnObj, symbol);
+    AppendString(cx, symbol, "\0");
+    if (!symbol)
+      return false;
 
     // Look up the function symbol.
-    fnptr = PR_FindFunctionSymbol(library, symbol.begin());
+    fnptr = PR_FindFunctionSymbol(library, symbol.finish().begin());
     if (!fnptr) {
       JS_ReportErrorASCII(cx, "couldn't find function symbol in library");
       return false;
     }
     data = &fnptr;
 
   } else {
     // 'typeObj' is another data type. Look up the data symbol.
-    AppendString(symbol, nameStr);
-    AppendString(symbol, "\0");
+    AppendString(cx, symbol, nameStr);
+    AppendString(cx, symbol, "\0");
+    if (!symbol)
+      return false;
 
-    data = PR_FindSymbol(library, symbol.begin());
+    data = PR_FindSymbol(library, symbol.finish().begin());
     if (!data) {
       JS_ReportErrorASCII(cx, "couldn't find symbol in library");
       return false;
     }
   }
 
   RootedObject result(cx, CData::Create(cx, typeObj, obj, data, isFunction));
   if (!result)
--- a/js/src/fuzz-tests/testStructuredCloneReader.cpp
+++ b/js/src/fuzz-tests/testStructuredCloneReader.cpp
@@ -34,25 +34,26 @@ testStructuredCloneReaderFuzz(const uint
     });
 
     if (!size) return 0;
 
     // Make sure to pad the buffer to a multiple of kSegmentAlignment
     const size_t kSegmentAlignment = 8;
     size_t buf_size = JS_ROUNDUP(size, kSegmentAlignment);
 
-    auto clonebuf = MakeUnique<JSStructuredCloneData>(0, 0, buf_size);
-    if (!clonebuf || !clonebuf->Init(buf_size, buf_size)) {
+    auto clonebuf = MakeUnique<JSStructuredCloneData>();
+    if (!clonebuf || !clonebuf->Init(buf_size)) {
         ReportOutOfMemory(gCx);
         return 0;
     }
 
-    // Initialize with zeros, including padding, then copy buffer
-    memset(clonebuf->Start(), '\0', buf_size);
-    js_memcpy(clonebuf->Start(), buf, size);
+    // Copy buffer then pad with zeroes.
+    clonebuf->AppendBytes((const char*)buf, size);
+    char padding[kSegmentAlignment] = {0};
+    clonebuf->AppendBytes(padding, buf_size - size);
 
     JS::StructuredCloneScope scope = JS::StructuredCloneScope::DifferentProcess;
 
     RootedValue deserialized(gCx);
     if (!JS_ReadStructuredClone(gCx, *clonebuf,
     			JS_STRUCTURED_CLONE_VERSION,
     			scope,
     			&deserialized, nullptr, nullptr))
--- a/js/src/jit/MCallOptimize.cpp
+++ b/js/src/jit/MCallOptimize.cpp
@@ -1928,22 +1928,31 @@ IonBuilder::inlineStrFromCharCode(CallIn
 {
     if (callInfo.argc() != 1 || callInfo.constructing()) {
         trackOptimizationOutcome(TrackedOutcome::CantInlineNativeBadForm);
         return InliningStatus_NotInlined;
     }
 
     if (getInlineReturnType() != MIRType::String)
         return InliningStatus_NotInlined;
-    if (callInfo.getArg(0)->type() != MIRType::Int32)
-        return InliningStatus_NotInlined;
+
+    MDefinition* codeUnit = callInfo.getArg(0);
+    if (codeUnit->type() != MIRType::Int32) {
+        // MTruncateToInt32 will always bail for objects and symbols, so don't
+        // try to inline String.fromCharCode() for these two value types.
+        if (codeUnit->mightBeType(MIRType::Object) || codeUnit->mightBeType(MIRType::Symbol))
+            return InliningStatus_NotInlined;
+
+        codeUnit = MTruncateToInt32::New(alloc(), codeUnit);
+        current->add(codeUnit->toInstruction());
+    }
 
     callInfo.setImplicitlyUsedUnchecked();
 
-    MFromCharCode* string = MFromCharCode::New(alloc(), callInfo.getArg(0));
+    MFromCharCode* string = MFromCharCode::New(alloc(), codeUnit);
     current->add(string);
     current->push(string);
     return InliningStatus_Inlined;
 }
 
 IonBuilder::InliningResult
 IonBuilder::inlineStrFromCodePoint(CallInfo& callInfo)
 {
--- a/js/src/jit/VMFunctions.cpp
+++ b/js/src/jit/VMFunctions.cpp
@@ -1572,16 +1572,18 @@ EqualStringsHelper(JSString* str1, JSStr
 {
     // IC code calls this directly so we shouldn't GC.
     AutoUnsafeCallWithABI unsafe;
 
     MOZ_ASSERT(str1->isAtom());
     MOZ_ASSERT(!str2->isAtom());
     MOZ_ASSERT(str1->length() == str2->length());
 
+    // ensureLinear is intentionally called with a nullptr to avoid OOM
+    // reporting; if it fails, we will continue to the next stub.
     JSLinearString* str2Linear = str2->ensureLinear(nullptr);
     if (!str2Linear)
         return false;
 
     return EqualChars(&str1->asLinear(), str2Linear);
 }
 
 bool
--- a/js/src/jit/mips32/MacroAssembler-mips32.h
+++ b/js/src/jit/mips32/MacroAssembler-mips32.h
@@ -147,18 +147,21 @@ class MacroAssemblerMIPS : public MacroA
     void ma_ss(FloatRegister ft, Address address);
 
     void ma_ldc1WordAligned(FloatRegister ft, Register base, int32_t off);
     void ma_sdc1WordAligned(FloatRegister ft, Register base, int32_t off);
 
     void ma_pop(FloatRegister f);
     void ma_push(FloatRegister f);
 
+    void ma_cmp_set(Register dst, Register lhs, ImmWord imm, Condition c) {
+        ma_cmp_set(dst, lhs, Imm32(uint32_t(imm.value)), c);
+    }
     void ma_cmp_set(Register dst, Register lhs, ImmPtr imm, Condition c) {
-        ma_cmp_set(dst, lhs, Imm32(uint32_t(imm.value)), c);
+        ma_cmp_set(dst, lhs, ImmWord(uintptr_t(imm.value)), c);
     }
     void ma_cmp_set(Register dst, Register lhs, Address addr, Condition c) {
         MOZ_ASSERT(lhs != ScratchRegister);
         ma_lw(ScratchRegister, addr);
         ma_cmp_set(dst, lhs, ScratchRegister, c);
     }
     void ma_cmp_set(Register dst, Address lhs, Register rhs, Condition c) {
         MOZ_ASSERT(rhs != ScratchRegister);
--- a/js/src/jsapi.cpp
+++ b/js/src/jsapi.cpp
@@ -6074,23 +6074,16 @@ JS_PutEscapedString(JSContext* cx, char*
 {
     AssertHeapIsIdle();
     JSLinearString* linearStr = str->ensureLinear(cx);
     if (!linearStr)
         return size_t(-1);
     return PutEscapedString(buffer, size, linearStr, quote);
 }
 
-JS_PUBLIC_API(bool)
-JS_FileEscapedString(FILE* fp, JSString* str, char quote)
-{
-    JSLinearString* linearStr = str->ensureLinear(nullptr);
-    return linearStr && FileEscapedString(fp, linearStr, quote);
-}
-
 JS_PUBLIC_API(JSString*)
 JS_NewDependentString(JSContext* cx, HandleString str, size_t start, size_t length)
 {
     AssertHeapIsIdle();
     CHECK_REQUEST(cx);
     return NewDependentString(cx, str, start, length);
 }
 
--- a/js/src/jsapi.h
+++ b/js/src/jsapi.h
@@ -4712,19 +4712,16 @@ extern JS_PUBLIC_API(bool)
 JS_CompareStrings(JSContext* cx, JSString* str1, JSString* str2, int32_t* result);
 
 extern JS_PUBLIC_API(bool)
 JS_StringEqualsAscii(JSContext* cx, JSString* str, const char* asciiBytes, bool* match);
 
 extern JS_PUBLIC_API(size_t)
 JS_PutEscapedString(JSContext* cx, char* buffer, size_t size, JSString* str, char quote);
 
-extern JS_PUBLIC_API(bool)
-JS_FileEscapedString(FILE* fp, JSString* str, char quote);
-
 /*
  * Extracting string characters and length.
  *
  * While getting the length of a string is infallible, getting the chars can
  * fail. As indicated by the lack of a JSContext parameter, there are two
  * special cases where getting the chars is infallible:
  *
  * The first case is for strings that have been atomized, e.g. directly by
--- a/js/src/vm/StringType.cpp
+++ b/js/src/vm/StringType.cpp
@@ -235,16 +235,17 @@ JSLinearString::dumpRepresentationChars(
     out.putChar('\n');
 }
 
 bool
 JSString::equals(const char* s)
 {
     JSLinearString* linear = ensureLinear(nullptr);
     if (!linear) {
+        // This is DEBUG-only code.
         fprintf(stderr, "OOM in JSString::equals!\n");
         return false;
     }
 
     return StringEqualsAscii(linear, s);
 }
 #endif /* DEBUG */
 
--- a/js/src/vm/StructuredClone.cpp
+++ b/js/src/vm/StructuredClone.cpp
@@ -154,26 +154,26 @@ PairToUInt64(uint32_t tag, uint32_t data
 }
 
 namespace js {
 
 template<typename T, typename AllocPolicy>
 struct BufferIterator {
     typedef mozilla::BufferList<AllocPolicy> BufferList;
 
-    explicit BufferIterator(BufferList& buffer)
+    explicit BufferIterator(const BufferList& buffer)
         : mBuffer(buffer)
         , mIter(buffer.Iter())
     {
         JS_STATIC_ASSERT(8 % sizeof(T) == 0);
     }
 
-    BufferIterator(const BufferIterator& other)
-        : mBuffer(other.mBuffer)
-        , mIter(other.mIter)
+    explicit BufferIterator(const JSStructuredCloneData& data)
+      : mBuffer(data.bufList_)
+      , mIter(data.Start())
     {
     }
 
     BufferIterator& operator=(const BufferIterator& other)
     {
         MOZ_ASSERT(&mBuffer == &other.mBuffer);
         mIter = other.mIter;
         return *this;
@@ -222,17 +222,17 @@ struct BufferIterator {
         MOZ_ASSERT(mIter.HasRoomFor(sizeof(T)));
         return *reinterpret_cast<T*>(mIter.Data());
     }
 
     bool canPeek() const {
         return mIter.HasRoomFor(sizeof(T));
     }
 
-    BufferList& mBuffer;
+    const BufferList& mBuffer;
     typename BufferList::IterImpl mIter;
 };
 
 SharedArrayRawBufferRefs&
 SharedArrayRawBufferRefs::operator=(SharedArrayRawBufferRefs&& other)
 {
     takeOwnership(Move(other));
     return *this;
@@ -289,51 +289,62 @@ SharedArrayRawBufferRefs::takeOwnership(
 void
 SharedArrayRawBufferRefs::releaseAll()
 {
     for (auto ref : refs_)
         ref->dropReference();
     refs_.clear();
 }
 
+// SCOutput provides an interface to write raw data -- eg uint64_ts, doubles,
+// arrays of bytes -- into a structured clone data output stream. It also knows
+// how to free any transferable data within that stream.
+//
+// Note that it contains a full JSStructuredCloneData object, which holds the
+// callbacks necessary to read/write/transfer/free the data. For the purpose of
+// this class, only the freeTransfer callback is relevant; the rest of the callbacks
+// are used by the higher-level JSStructuredCloneWriter interface.
 struct SCOutput {
   public:
-    using Iter = BufferIterator<uint64_t, TempAllocPolicy>;
+    using Iter = BufferIterator<uint64_t, SystemAllocPolicy>;
 
     explicit SCOutput(JSContext* cx);
 
     JSContext* context() const { return cx; }
 
     MOZ_MUST_USE bool write(uint64_t u);
     MOZ_MUST_USE bool writePair(uint32_t tag, uint32_t data);
     MOZ_MUST_USE bool writeDouble(double d);
     MOZ_MUST_USE bool writeBytes(const void* p, size_t nbytes);
     MOZ_MUST_USE bool writeChars(const Latin1Char* p, size_t nchars);
     MOZ_MUST_USE bool writeChars(const char16_t* p, size_t nchars);
     MOZ_MUST_USE bool writePtr(const void*);
 
     template <class T>
     MOZ_MUST_USE bool writeArray(const T* p, size_t nbytes);
 
-    MOZ_MUST_USE bool extractBuffer(JSStructuredCloneData* data);
-    void discardTransferables(const JSStructuredCloneCallbacks* cb, void* cbClosure);
+    void setCallbacks(const JSStructuredCloneCallbacks* callbacks,
+                      void* closure,
+                      OwnTransferablePolicy policy)
+    {
+        buf.setCallbacks(callbacks, closure, policy);
+    }
+    void extractBuffer(JSStructuredCloneData* data) { *data = Move(buf); }
+    void discardTransferables();
 
     uint64_t tell() const { return buf.Size(); }
     uint64_t count() const { return buf.Size() / sizeof(uint64_t); }
-    Iter iter() {
-        return BufferIterator<uint64_t, TempAllocPolicy>(buf);
-    }
+    Iter iter() { return Iter(buf); }
 
     size_t offset(Iter dest) {
         return dest - iter();
     }
 
-  private:
     JSContext* cx;
-    mozilla::BufferList<TempAllocPolicy> buf;
+    JSStructuredCloneData buf;
 };
 
 class SCInput {
     typedef js::BufferIterator<uint64_t, SystemAllocPolicy> BufferIterator;
 
   public:
     SCInput(JSContext* cx, JSStructuredCloneData& data);
 
@@ -456,46 +467,40 @@ struct JSStructuredCloneWriter {
     explicit JSStructuredCloneWriter(JSContext* cx,
                                      JS::StructuredCloneScope scope,
                                      JS::CloneDataPolicy cloneDataPolicy,
                                      const JSStructuredCloneCallbacks* cb,
                                      void* cbClosure,
                                      const Value& tVal)
         : out(cx), scope(scope), objs(out.context()),
           counts(out.context()), entries(out.context()),
-          memory(out.context()), callbacks(cb),
-          closure(cbClosure), transferable(out.context(), tVal),
+          memory(out.context()),
+          transferable(out.context(), tVal),
           transferableObjects(out.context(), GCHashSet<JSObject*>(cx)),
           cloneDataPolicy(cloneDataPolicy)
-    {}
+    {
+        out.setCallbacks(cb, cbClosure, OwnTransferablePolicy::NoTransferables);
+    }
 
     ~JSStructuredCloneWriter();
 
     bool init() {
         if (!memory.init()) {
             ReportOutOfMemory(context());
             return false;
         }
         return parseTransferable() && writeHeader() && writeTransferMap();
     }
 
     bool write(HandleValue v);
 
     SCOutput& output() { return out; }
 
-    bool extractBuffer(JSStructuredCloneData* data) {
-        bool success = out.extractBuffer(data);
-        if (success) {
-            // Move the SharedArrayRawBuf references here, SCOutput::extractBuffer
-            // moves the serialized data.
-            data->refsHeld_.takeOwnership(Move(refsHeld));
-            data->setOptionalCallbacks(callbacks, closure,
-                                       OwnTransferablePolicy::OwnsTransferablesIfAny);
-        }
-        return success;
+    void extractBuffer(JSStructuredCloneData* newData) {
+        out.extractBuffer(newData);
     }
 
     JS::StructuredCloneScope cloneScope() const { return scope; }
 
   private:
     JSStructuredCloneWriter() = delete;
     JSStructuredCloneWriter(const JSStructuredCloneWriter&) = delete;
 
@@ -549,31 +554,22 @@ struct JSStructuredCloneWriter {
     // algorithm.  memory is a superset of objs; items are never removed from
     // Memory until a serialization operation is finished
     using CloneMemory = GCHashMap<JSObject*,
                                   uint32_t,
                                   MovableCellHasher<JSObject*>,
                                   SystemAllocPolicy>;
     Rooted<CloneMemory> memory;
 
-    // The user defined callbacks that will be used for cloning.
-    const JSStructuredCloneCallbacks* callbacks;
-
-    // Any value passed to JS_WriteStructuredClone.
-    void* closure;
-
     // Set of transferable objects
     RootedValue transferable;
     Rooted<GCHashSet<JSObject*>> transferableObjects;
 
     const JS::CloneDataPolicy cloneDataPolicy;
 
-    // SharedArrayRawBuffers whose reference counts we have incremented.
-    SharedArrayRawBufferRefs refsHeld;
-
     friend bool JS_WriteString(JSStructuredCloneWriter* w, HandleString str);
     friend bool JS_WriteTypedArray(JSStructuredCloneWriter* w, HandleValue v);
     friend bool JS_ObjectNotWritten(JSStructuredCloneWriter* w, HandleObject obj);
 };
 
 JS_FRIEND_API(uint64_t)
 js::GetSCOffset(JSStructuredCloneWriter* writer)
 {
@@ -621,17 +617,22 @@ ReportDataCloneError(JSContext* cx,
 bool
 WriteStructuredClone(JSContext* cx, HandleValue v, JSStructuredCloneData* bufp,
                      JS::StructuredCloneScope scope,
                      JS::CloneDataPolicy cloneDataPolicy,
                      const JSStructuredCloneCallbacks* cb, void* cbClosure,
                      const Value& transferable)
 {
     JSStructuredCloneWriter w(cx, scope, cloneDataPolicy, cb, cbClosure, transferable);
-    return w.init() && w.write(v) && w.extractBuffer(bufp);
+    if (!w.init())
+        return false;
+    if (!w.write(v))
+        return false;
+    w.extractBuffer(bufp);
+    return true;
 }
 
 bool
 ReadStructuredClone(JSContext* cx, JSStructuredCloneData& data,
                     JS::StructuredCloneScope scope, MutableHandleValue vp,
                     const JSStructuredCloneCallbacks* cb, void* cbClosure)
 {
     SCInput in(cx, data);
@@ -712,34 +713,33 @@ DiscardTransferables(mozilla::BufferList
             MOZ_ASSERT(false, "unknown ownership");
         }
     }
 }
 
 static bool
 StructuredCloneHasTransferObjects(const JSStructuredCloneData& data)
 {
-    auto iter = data.Iter();
-
     if (data.Size() < sizeof(uint64_t))
         return false;
 
     uint64_t u;
-    MOZ_ALWAYS_TRUE(data.ReadBytes(iter, reinterpret_cast<char*>(&u), sizeof(u)));
+    BufferIterator<uint64_t, SystemAllocPolicy> iter(data);
+    MOZ_ALWAYS_TRUE(iter.readBytes(reinterpret_cast<char*>(&u), sizeof(u)));
     uint32_t tag = uint32_t(u >> 32);
     return (tag == SCTAG_TRANSFER_MAP_HEADER);
 }
 
 namespace js {
 
 SCInput::SCInput(JSContext* cx, JSStructuredCloneData& data)
     : cx(cx), point(data)
 {
 
-    static_assert(JSStructuredCloneData::kSegmentAlignment % 8 == 0,
+    static_assert(JSStructuredCloneData::BufferList::kSegmentAlignment % 8 == 0,
                   "structured clone buffer reads should be aligned");
     MOZ_ASSERT(data.Size() % 8 == 0);
 }
 
 bool
 SCInput::read(uint64_t* p)
 {
     if (!point.canPeek()) {
@@ -901,25 +901,28 @@ SCInput::readPtr(void** p)
     if (!readNativeEndian(&u))
         return false;
     *p = reinterpret_cast<void*>(NativeEndian::swapFromLittleEndian(u));
     return true;
 }
 
 SCOutput::SCOutput(JSContext* cx)
     : cx(cx)
-    , buf(0, 0, 4096, cx)
 {
 }
 
 bool
 SCOutput::write(uint64_t u)
 {
     uint64_t v = NativeEndian::swapToLittleEndian(u);
-    return buf.WriteBytes(reinterpret_cast<char*>(&v), sizeof(u));
+    if (!buf.AppendBytes(reinterpret_cast<char*>(&v), sizeof(u))) {
+        ReportOutOfMemory(context());
+        return false;
+    }
+    return true;
 }
 
 bool
 SCOutput::writePair(uint32_t tag, uint32_t data)
 {
     // As it happens, the tag word appears after the data word in the output.
     // This is because exponents occupy the last 2 bytes of doubles on the
     // little-endian platforms we care most about.
@@ -949,43 +952,43 @@ SCOutput::writeArray(const T* p, size_t 
     JS_STATIC_ASSERT(8 % sizeof(T) == 0);
     JS_STATIC_ASSERT(sizeof(uint64_t) % sizeof(T) == 0);
 
     if (nelems == 0)
         return true;
 
     for (size_t i = 0; i < nelems; i++) {
         T value = NativeEndian::swapToLittleEndian(p[i]);
-        if (!buf.WriteBytes(reinterpret_cast<char*>(&value), sizeof(value)))
+        if (!buf.AppendBytes(reinterpret_cast<char*>(&value), sizeof(value)))
             return false;
     }
 
     // Zero-pad to 8 bytes boundary.
     size_t padbytes = ComputePadding(nelems, sizeof(T));
     char zeroes[sizeof(uint64_t)] = { 0 };
-    if (!buf.WriteBytes(zeroes, padbytes))
+    if (!buf.AppendBytes(zeroes, padbytes))
         return false;
 
     return true;
 }
 
 template <>
 bool
 SCOutput::writeArray<uint8_t>(const uint8_t* p, size_t nelems)
 {
     if (nelems == 0)
         return true;
 
-    if (!buf.WriteBytes(reinterpret_cast<const char*>(p), nelems))
+    if (!buf.AppendBytes(reinterpret_cast<const char*>(p), nelems))
         return false;
 
     // zero-pad to 8 bytes boundary
     size_t padbytes = ComputePadding(nelems, 1);
     char zeroes[sizeof(uint64_t)] = { 0 };
-    if (!buf.WriteBytes(zeroes, padbytes))
+    if (!buf.AppendBytes(zeroes, padbytes))
         return false;
 
     return true;
 }
 
 bool
 SCOutput::writeBytes(const void* p, size_t nbytes)
 {
@@ -1009,54 +1012,41 @@ SCOutput::writeChars(const Latin1Char* p
 }
 
 bool
 SCOutput::writePtr(const void* p)
 {
     return write(reinterpret_cast<uint64_t>(p));
 }
 
-bool
-SCOutput::extractBuffer(JSStructuredCloneData* data)
+void
+SCOutput::discardTransferables()
 {
-    bool success;
-    mozilla::BufferList<SystemAllocPolicy> out =
-        buf.MoveFallible<SystemAllocPolicy>(&success);
-    if (!success) {
-        ReportOutOfMemory(cx);
-        return false;
-    }
-    *data = JSStructuredCloneData(Move(out));
-    return true;
-}
-
-void
-SCOutput::discardTransferables(const JSStructuredCloneCallbacks* cb, void* cbClosure)
-{
-    DiscardTransferables(buf, cb, cbClosure);
+    buf.discardTransferables();
 }
 
 } // namespace js
 
-JSStructuredCloneData::~JSStructuredCloneData()
+
+void
+JSStructuredCloneData::discardTransferables()
 {
     if (!Size())
         return;
     if (ownTransferables_ == OwnTransferablePolicy::OwnsTransferablesIfAny)
-        DiscardTransferables(*this, callbacks_, closure_);
+        DiscardTransferables(bufList_, callbacks_, closure_);
 }
 
 JS_STATIC_ASSERT(JSString::MAX_LENGTH < UINT32_MAX);
 
 JSStructuredCloneWriter::~JSStructuredCloneWriter()
 {
     // Free any transferable data left lying around in the buffer
-    if (out.count()) {
-        out.discardTransferables(callbacks, closure);
-    }
+    if (out.count())
+        out.discardTransferables();
 }
 
 bool
 JSStructuredCloneWriter::parseTransferable()
 {
     // NOTE: The transferables set is tested for non-emptiness at various
     //       junctures in structured cloning, so this set must be initialized
     //       by this method in all non-error cases.
@@ -1124,21 +1114,21 @@ JSStructuredCloneWriter::parseTransferab
         // but that is not currently implemented.
 
         else if (unwrappedObj->is<ArrayBufferObject>()) {
             if (unwrappedObj->as<ArrayBufferObject>().isExternal())
                 return reportDataCloneError(JS_SCERR_TRANSFERABLE);
         }
 
         else  {
-            if (!callbacks || !callbacks->canTransfer)
+            if (!out.buf.callbacks_ || !out.buf.callbacks_->canTransfer)
                 return reportDataCloneError(JS_SCERR_TRANSFERABLE);
 
             JSAutoCompartment ac(cx, unwrappedObj);
-            if (!callbacks->canTransfer(cx, unwrappedObj, closure))
+            if (!out.buf.callbacks_->canTransfer(cx, unwrappedObj, out.buf.closure_))
                 return false;
         }
 
         // No duplicates allowed
         auto p = transferableObjects.lookupForAdd(tObj);
         if (p)
             return reportDataCloneError(JS_SCERR_DUP_TRANSFERABLE);
 
@@ -1147,17 +1137,17 @@ JSStructuredCloneWriter::parseTransferab
     }
 
     return true;
 }
 
 bool
 JSStructuredCloneWriter::reportDataCloneError(uint32_t errorId)
 {
-    ReportDataCloneError(context(), callbacks, errorId);
+    ReportDataCloneError(context(), out.buf.callbacks_, errorId);
     return false;
 }
 
 bool
 JSStructuredCloneWriter::writeString(uint32_t tag, JSString* str)
 {
     JSLinearString* linear = str->ensureLinear(context());
     if (!linear)
@@ -1280,17 +1270,17 @@ JSStructuredCloneWriter::writeSharedArra
     if (scope > JS::StructuredCloneScope::SameProcessDifferentThread) {
         JS_ReportErrorNumberASCII(context(), GetErrorMessage, nullptr, JSMSG_SC_SHMEM_POLICY);
         return false;
     }
 
     Rooted<SharedArrayBufferObject*> sharedArrayBuffer(context(), &CheckedUnwrap(obj)->as<SharedArrayBufferObject>());
     SharedArrayRawBuffer* rawbuf = sharedArrayBuffer->rawBufferObject();
 
-    if (!refsHeld.acquire(context(), rawbuf))
+    if (!out.buf.refsHeld_.acquire(context(), rawbuf))
         return false;
 
     // We must serialize the length so that the buffer object arrives in the
     // receiver with the same length, and not with the length read from the
     // rawbuf - that length can be different, and it can change at any time.
 
     intptr_t p = reinterpret_cast<intptr_t>(rawbuf);
     uint32_t byteLength = sharedArrayBuffer->byteLength();
@@ -1606,18 +1596,18 @@ JSStructuredCloneWriter::startWrite(Hand
         } else if (cls == ESClass::Map) {
             return traverseMap(obj);
         } else if (cls == ESClass::Set) {
             return traverseSet(obj);
         } else if (SavedFrame::isSavedFrameOrWrapperAndNotProto(*obj)) {
             return traverseSavedFrame(obj);
         }
 
-        if (callbacks && callbacks->write)
-            return callbacks->write(context(), this, obj, closure);
+        if (out.buf.callbacks_ && out.buf.callbacks_->write)
+            return out.buf.callbacks_->write(context(), this, obj, out.buf.closure_);
         // else fall through
     }
 
     return reportDataCloneError(JS_SCERR_UNSUPPORTED_TYPE);
 }
 
 bool
 JSStructuredCloneWriter::writeHeader()
@@ -1750,19 +1740,19 @@ JSStructuredCloneWriter::transferOwnersh
                 content = bufContents.data();
                 if (bufContents.kind() == ArrayBufferObject::MAPPED)
                     ownership = JS::SCTAG_TMO_MAPPED_DATA;
                 else
                     ownership = JS::SCTAG_TMO_ALLOC_DATA;
                 extraData = nbytes;
             }
         } else {
-            if (!callbacks || !callbacks->writeTransfer)
+            if (!out.buf.callbacks_ || !out.buf.callbacks_->writeTransfer)
                 return reportDataCloneError(JS_SCERR_TRANSFERABLE);
-            if (!callbacks->writeTransfer(cx, obj, closure, &tag, &ownership, &content, &extraData))
+            if (!out.buf.callbacks_->writeTransfer(cx, obj, out.buf.closure_, &tag, &ownership, &content, &extraData))
                 return false;
             MOZ_ASSERT(tag > SCTAG_TRANSFER_MAP_PENDING_ENTRY);
         }
 
         point.write(NativeEndian::swapToLittleEndian(PairToUInt64(tag, ownership)));
         point.next();
         point.write(NativeEndian::swapToLittleEndian(reinterpret_cast<uint64_t>(content)));
         point.next();
@@ -2826,87 +2816,51 @@ JSAutoStructuredCloneBuffer::operator=(J
     MOZ_ASSERT(scope_ == other.scope_);
     clear();
     data_.ownTransferables_ = other.data_.ownTransferables_;
     other.steal(&data_, &version_, &data_.callbacks_, &data_.closure_);
     return *this;
 }
 
 void
-JSAutoStructuredCloneBuffer::clear(const JSStructuredCloneCallbacks* optionalCallbacks,
-                                   void* optionalClosure)
+JSAutoStructuredCloneBuffer::clear()
 {
-    if (!data_.Size())
-        return;
-
-    const JSStructuredCloneCallbacks* callbacks =
-        optionalCallbacks ?  optionalCallbacks : data_.callbacks_;
-    void* closure = optionalClosure ?  optionalClosure : data_.closure_;
-
-    if (data_.ownTransferables_ == OwnTransferablePolicy::OwnsTransferablesIfAny)
-        DiscardTransferables(data_, callbacks, closure);
+    data_.discardTransferables();
     data_.ownTransferables_ = OwnTransferablePolicy::NoTransferables;
     data_.refsHeld_.releaseAll();
     data_.Clear();
     version_ = 0;
 }
 
-bool
-JSAutoStructuredCloneBuffer::copy(JSContext* cx, const JSStructuredCloneData& srcData,
-                                  uint32_t version, const JSStructuredCloneCallbacks* callbacks,
-                                  void* closure)
-{
-    // transferable objects cannot be copied
-    if (StructuredCloneHasTransferObjects(srcData))
-        return false;
-
-    clear();
-
-    auto iter = srcData.Iter();
-    while (!iter.Done()) {
-        if (!data_.WriteBytes(iter.Data(), iter.RemainingInSegment()))
-            return false;
-        iter.Advance(srcData, iter.RemainingInSegment());
-    }
-
-    version_ = version;
-
-    if (!data_.refsHeld_.acquireAll(cx, srcData.refsHeld_))
-        return false;
-
-    data_.setOptionalCallbacks(callbacks, closure, OwnTransferablePolicy::NoTransferables);
-    return true;
-}
-
 void
 JSAutoStructuredCloneBuffer::adopt(JSStructuredCloneData&& data, uint32_t version,
                                    const JSStructuredCloneCallbacks* callbacks,
                                    void* closure)
 {
     clear();
     data_ = Move(data);
     version_ = version;
-    data_.setOptionalCallbacks(callbacks, closure, OwnTransferablePolicy::OwnsTransferablesIfAny);
+    data_.setCallbacks(callbacks, closure, OwnTransferablePolicy::OwnsTransferablesIfAny);
 }
 
 void
 JSAutoStructuredCloneBuffer::steal(JSStructuredCloneData* data, uint32_t* versionp,
                                    const JSStructuredCloneCallbacks** callbacks,
                                    void** closure)
 {
     if (versionp)
         *versionp = version_;
     if (callbacks)
         *callbacks = data_.callbacks_;
     if (closure)
         *closure = data_.closure_;
     *data = Move(data_);
 
     version_ = 0;
-    data_.setOptionalCallbacks(nullptr, nullptr, OwnTransferablePolicy::NoTransferables);
+    data_.setCallbacks(nullptr, nullptr, OwnTransferablePolicy::NoTransferables);
 }
 
 bool
 JSAutoStructuredCloneBuffer::read(JSContext* cx, MutableHandleValue vp,
                                   const JSStructuredCloneCallbacks* optionalCallbacks,
                                   void* closure)
 {
     MOZ_ASSERT(cx);
--- a/layout/base/nsLayoutUtils.cpp
+++ b/layout/base/nsLayoutUtils.cpp
@@ -155,17 +155,16 @@ using namespace mozilla::image;
 using namespace mozilla::layers;
 using namespace mozilla::layout;
 using namespace mozilla::gfx;
 using mozilla::dom::HTMLMediaElementBinding::HAVE_NOTHING;
 using mozilla::dom::HTMLMediaElementBinding::HAVE_METADATA;
 
 #define WEBKIT_PREFIXES_ENABLED_PREF_NAME "layout.css.prefixes.webkit"
 #define TEXT_ALIGN_UNSAFE_ENABLED_PREF_NAME "layout.css.text-align-unsafe-value.enabled"
-#define FLOAT_LOGICAL_VALUES_ENABLED_PREF_NAME "layout.css.float-logical-values.enabled"
 #define INTERCHARACTER_RUBY_ENABLED_PREF_NAME "layout.css.ruby.intercharacter.enabled"
 #define CONTENT_SELECT_ENABLED_PREF_NAME "dom.select_popup_in_content.enabled"
 
 // The time in number of frames that we estimate for a refresh driver
 // to be quiescent
 #define DEFAULT_QUIESCENT_FRAMES 2
 // The time (milliseconds) we estimate is needed between the end of an
 // idle time and the next Tick.
@@ -310,71 +309,16 @@ TextAlignUnsafeEnabledPrefChangeCallback
   MOZ_ASSERT(sIndexOfUnsafeInTextAlignTable >= 0);
   nsCSSProps::kTextAlignKTable[sIndexOfUnsafeInTextAlignTable].mKeyword =
     isTextAlignUnsafeEnabled ? eCSSKeyword_unsafe : eCSSKeyword_UNKNOWN;
   MOZ_ASSERT(sIndexOfUnsafeInTextAlignLastTable >= 0);
   nsCSSProps::kTextAlignLastKTable[sIndexOfUnsafeInTextAlignLastTable].mKeyword =
     isTextAlignUnsafeEnabled ? eCSSKeyword_unsafe : eCSSKeyword_UNKNOWN;
 }
 
-// When the pref "layout.css.float-logical-values.enabled" changes, this
-// function is called to let us update kFloatKTable & kClearKTable,
-// to selectively disable or restore the entries for logical values
-// (inline-start and inline-end) in those tables.
-static void
-FloatLogicalValuesEnabledPrefChangeCallback(const char* aPrefName,
-                                            void* aClosure)
-{
-  NS_ASSERTION(strcmp(aPrefName, FLOAT_LOGICAL_VALUES_ENABLED_PREF_NAME) == 0,
-               "Did you misspell " FLOAT_LOGICAL_VALUES_ENABLED_PREF_NAME " ?");
-
-  static bool sIsInitialized;
-  static int32_t sIndexOfInlineStartInFloatTable;
-  static int32_t sIndexOfInlineEndInFloatTable;
-  static int32_t sIndexOfInlineStartInClearTable;
-  static int32_t sIndexOfInlineEndInClearTable;
-  bool isFloatLogicalValuesEnabled =
-    Preferences::GetBool(FLOAT_LOGICAL_VALUES_ENABLED_PREF_NAME, false);
-
-  if (!sIsInitialized) {
-    // First run: find the position of "inline-start" in kFloatKTable.
-    sIndexOfInlineStartInFloatTable =
-      nsCSSProps::FindIndexOfKeyword(eCSSKeyword_inline_start,
-                                     nsCSSProps::kFloatKTable);
-    // First run: find the position of "inline-end" in kFloatKTable.
-    sIndexOfInlineEndInFloatTable =
-      nsCSSProps::FindIndexOfKeyword(eCSSKeyword_inline_end,
-                                     nsCSSProps::kFloatKTable);
-    // First run: find the position of "inline-start" in kClearKTable.
-    sIndexOfInlineStartInClearTable =
-      nsCSSProps::FindIndexOfKeyword(eCSSKeyword_inline_start,
-                                     nsCSSProps::kClearKTable);
-    // First run: find the position of "inline-end" in kClearKTable.
-    sIndexOfInlineEndInClearTable =
-      nsCSSProps::FindIndexOfKeyword(eCSSKeyword_inline_end,
-                                     nsCSSProps::kClearKTable);
-    sIsInitialized = true;
-  }
-
-  // OK -- now, stomp on or restore the logical entries in the keyword tables,
-  // depending on whether the pref is enabled vs. disabled.
-  MOZ_ASSERT(sIndexOfInlineStartInFloatTable >= 0);
-  nsCSSProps::kFloatKTable[sIndexOfInlineStartInFloatTable].mKeyword =
-    isFloatLogicalValuesEnabled ? eCSSKeyword_inline_start : eCSSKeyword_UNKNOWN;
-  MOZ_ASSERT(sIndexOfInlineEndInFloatTable >= 0);
-  nsCSSProps::kFloatKTable[sIndexOfInlineEndInFloatTable].mKeyword =
-    isFloatLogicalValuesEnabled ? eCSSKeyword_inline_end : eCSSKeyword_UNKNOWN;
-  MOZ_ASSERT(sIndexOfInlineStartInClearTable >= 0);
-  nsCSSProps::kClearKTable[sIndexOfInlineStartInClearTable].mKeyword =
-    isFloatLogicalValuesEnabled ? eCSSKeyword_inline_start : eCSSKeyword_UNKNOWN;
-  MOZ_ASSERT(sIndexOfInlineEndInClearTable >= 0);
-  nsCSSProps::kClearKTable[sIndexOfInlineEndInClearTable].mKeyword =
-    isFloatLogicalValuesEnabled ? eCSSKeyword_inline_end : eCSSKeyword_UNKNOWN;
-}
-
 template<typename TestType>
 static bool
 HasMatchingAnimations(EffectSet* aEffects, TestType&& aTest)
 {
   for (KeyframeEffectReadOnly* effect : *aEffects) {
     if (aTest(*effect)) {
       return true;
     }
@@ -8212,18 +8156,16 @@ struct PrefCallbacks
   const char* name;
   PrefChangedFunc func;
 };
 static const PrefCallbacks kPrefCallbacks[] = {
   { WEBKIT_PREFIXES_ENABLED_PREF_NAME,
     WebkitPrefixEnabledPrefChangeCallback },
   { TEXT_ALIGN_UNSAFE_ENABLED_PREF_NAME,
     TextAlignUnsafeEnabledPrefChangeCallback },
-  { FLOAT_LOGICAL_VALUES_ENABLED_PREF_NAME,
-    FloatLogicalValuesEnabledPrefChangeCallback },
 };
 
 /* static */
 void
 nsLayoutUtils::Initialize()
 {
   Preferences::AddUintVarCache(&sFontSizeInflationMaxRatio,
                                "font.size.inflation.maxRatio");
--- a/layout/base/nsPresArena.h
+++ b/layout/base/nsPresArena.h
@@ -105,21 +105,19 @@ public:
   void ClearArenaRefPtrs(mozilla::ArenaObjectID aObjectID);
 
   /**
    * Increment nsWindowSizes with sizes of interesting objects allocated in this
    * arena.
    */
   void AddSizeOfExcludingThis(nsWindowSizes& aWindowSizes) const;
 
-#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
   void Check() {
     mPool.Check();
   }
-#endif
 
 private:
   void* Allocate(uint32_t aCode, size_t aSize);
   void Free(uint32_t aCode, void* aPtr);
 
   inline void ClearArenaRefPtrWithoutDeregistering(
       void* aPtr,
       mozilla::ArenaObjectID aObjectID);
--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -2776,20 +2776,36 @@ ComputeClipForMaskItem(nsDisplayListBuil
     // The resulting clip is relative to the reference frame, but the caller
     // expects it to be relative to the masked frame, so adjust it.
     result -= toReferenceFrame;
     return Some(result);
   }
   return Nothing();
 }
 
+struct AutoCheckBuilder {
+  explicit AutoCheckBuilder(nsDisplayListBuilder* aBuilder)
+    : mBuilder(aBuilder)
+  {
+    aBuilder->Check();
+  }
+
+  ~AutoCheckBuilder()
+  {
+    mBuilder->Check();
+  }
+
+  nsDisplayListBuilder* mBuilder;
+};
+
 void
 nsIFrame::BuildDisplayListForStackingContext(nsDisplayListBuilder* aBuilder,
                                              nsDisplayList*        aList,
                                              bool*                 aCreatedContainerItem) {
+  AutoCheckBuilder check(aBuilder);
   if (GetStateBits() & NS_FRAME_TOO_DEEP_IN_FRAME_TREE)
     return;
 
   // Replaced elements have their visibility handled here, because
   // they're visually atomic
   if (IsFrameOfType(eReplaced) && !IsVisibleForPainting(aBuilder))
     return;
 
@@ -3064,17 +3080,19 @@ nsIFrame::BuildDisplayListForStackingCon
       eventRegions->AddFrame(aBuilder, this);
       aBuilder->SetLayerEventRegions(eventRegions);
     }
 
     aBuilder->BuildCompositorHitTestInfoIfNeeded(this, set.BorderBackground(),
                                                  true);
 
     MarkAbsoluteFramesForDisplayList(aBuilder);
+    aBuilder->Check();
     BuildDisplayList(aBuilder, set);
+    aBuilder->Check();
 
     // Blend modes are a real pain for retained display lists. We build a blend
     // container item if the built list contains any blend mode items within
     // the current stacking context. This can change without an invalidation
     // to the stacking context frame, or the blend mode frame (e.g. by moving
     // an intermediate frame).
     // When we gain/remove a blend container item, we need to mark this frame
     // as invalid and have the full display list for merging to track
@@ -3112,17 +3130,19 @@ nsIFrame::BuildDisplayListForStackingCon
         // If this is the root frame, then the previous call to
         // MarkAbsoluteFramesForDisplayList might have stored some fixed
         // background data. Clear that now.
         if (!GetParent()) {
           aBuilder->ClearFixedBackgroundDisplayData();
         }
 
         MarkAbsoluteFramesForDisplayList(aBuilder);
+        aBuilder->Check();
         BuildDisplayList(aBuilder, set);
+        aBuilder->Check();
       }
     }
 
     if (eventRegions) {
       // If the event regions item ended up empty, throw it away rather than
       // adding it to the display list.
       if (!eventRegions->IsEmpty()) {
         set.BorderBackground()->AppendToBottom(eventRegions);
@@ -3510,16 +3530,17 @@ DescendIntoChild(nsDisplayListBuilder* a
   return true;
 }
 
 void
 nsIFrame::BuildDisplayListForChild(nsDisplayListBuilder*   aBuilder,
                                    nsIFrame*               aChild,
                                    const nsDisplayListSet& aLists,
                                    uint32_t                aFlags) {
+  AutoCheckBuilder check(aBuilder);
   // If painting is restricted to just the background of the top level frame,
   // then we have nothing to do here.
   if (aBuilder->IsBackgroundOnly())
     return;
 
   if (aBuilder->IsForGenerateGlyphMask() ||
       aBuilder->IsForPaintingSelectionBG()) {
     if (!aChild->IsTextFrame() && aChild->IsLeaf()) {
@@ -3572,17 +3593,19 @@ nsIFrame::BuildDisplayListForChild(nsDis
 
     nsDisplayLayerEventRegions* eventRegions = aBuilder->GetLayerEventRegions();
     if (eventRegions) {
       eventRegions->AddFrame(aBuilder, child);
     }
 
     child->MarkAbsoluteFramesForDisplayList(aBuilder);
     aBuilder->AdjustWindowDraggingRegion(child);
+    aBuilder->Check();
     child->BuildDisplayList(aBuilder, aLists);
+    aBuilder->Check();
     aBuilder->DisplayCaret(child, aLists.Content());
 #ifdef DEBUG
     DisplayDebugBorders(aBuilder, child, aLists);
 #endif
     return;
   }
 
   const bool isSVG = child->GetStateBits() & NS_FRAME_SVG_LAYOUT;
@@ -3820,17 +3843,19 @@ nsIFrame::BuildDisplayListForChild(nsDis
       // Not a pseudo or real stacking context. Do the simple thing and
       // return early.
 
       aBuilder->BuildCompositorHitTestInfoIfNeeded(child,
                                                    aLists.BorderBackground(),
                                                    differentAGR);
 
       aBuilder->AdjustWindowDraggingRegion(child);
+      aBuilder->Check();
       child->BuildDisplayList(aBuilder, aLists);
+      aBuilder->Check();
       aBuilder->DisplayCaret(child, aLists.Content());
 #ifdef DEBUG
       DisplayDebugBorders(aBuilder, child, aLists);
 #endif
       return;
     }
 
     // A pseudo-stacking context (e.g., a positioned element with z-index auto).
@@ -3840,17 +3865,19 @@ nsIFrame::BuildDisplayListForChild(nsDis
     nsDisplayListCollection pseudoStack(aBuilder);
 
     aBuilder->BuildCompositorHitTestInfoIfNeeded(child,
                                                  pseudoStack.BorderBackground(),
                                                  differentAGR);
 
     aBuilder->AdjustWindowDraggingRegion(child);
     nsDisplayListBuilder::AutoContainerASRTracker contASRTracker(aBuilder);
+    aBuilder->Check();
     child->BuildDisplayList(aBuilder, pseudoStack);
+    aBuilder->Check();
     if (aBuilder->DisplayCaret(child, pseudoStack.Content())) {
       canSkipWrapList = false;
     }
     wrapListASR = contASRTracker.GetContainerASR();
 
     list.AppendToTop(pseudoStack.BorderBackground());
     list.AppendToTop(pseudoStack.BlockBorderBackgrounds());
     list.AppendToTop(pseudoStack.Floats());
--- a/layout/painting/nsDisplayList.h
+++ b/layout/painting/nsDisplayList.h
@@ -706,19 +706,17 @@ public:
   }
   AnimatedGeometryRoot* GetRootAnimatedGeometryRoot() {
     return mRootAGR;
   }
 
   void RecomputeCurrentAnimatedGeometryRoot();
 
   void Check() {
-#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
     mPool.Check();
-#endif
   }
 
   /**
    * Returns true if merging and flattening of display lists should be
    * performed while computing visibility.
    */
   bool AllowMergingAndFlattening() { return mAllowMergingAndFlattening; }
   void SetAllowMergingAndFlattening(bool aAllow) { mAllowMergingAndFlattening = aAllow; }
--- a/layout/reftests/floats/reftest.list
+++ b/layout/reftests/floats/reftest.list
@@ -91,20 +91,20 @@ fuzzy-if(skiaContent,1,12000) == float-i
 == float-in-rtl-vrl-4b.html float-in-rtl-vrl-4-ref.html
 == float-in-rtl-vrl-4c.html float-in-rtl-vrl-4-ref.html
 == float-in-rtl-vrl-4d.html float-in-rtl-vrl-4-ref.html
 fuzzy-if(OSX==1010,28,7) fuzzy-if(Android,16,2) == orthogonal-floats-1a.html orthogonal-floats-1-ref.html
 fuzzy-if(OSX==1010,28,7) == orthogonal-floats-1b.html orthogonal-floats-1-ref.html
 fuzzy-if(OSX==1010,103,802) fuzzy-if(winWidget,135,700) == orthogonal-floats-1c.html orthogonal-floats-1-ref.html
 fuzzy-if(OSX==1010,103,802) fuzzy-if(winWidget,135,700) == orthogonal-floats-1d.html orthogonal-floats-1-ref.html
 
-pref(layout.css.float-logical-values.enabled,true) == logical-float-side-1.html logical-float-side-1-ref.html
-pref(layout.css.float-logical-values.enabled,true) == logical-float-side-2.html logical-float-side-2-ref.html
-pref(layout.css.float-logical-values.enabled,true) == logical-float-side-3.html logical-float-side-3-ref.html
-pref(layout.css.float-logical-values.enabled,true) == logical-float-side-4.html logical-float-side-4-ref.html
+== logical-float-side-1.html logical-float-side-1-ref.html
+== logical-float-side-2.html logical-float-side-2-ref.html
+== logical-float-side-3.html logical-float-side-3-ref.html
+== logical-float-side-4.html logical-float-side-4-ref.html
 
 == float-in-rtl-slr-1a.html float-in-rtl-slr-1-ref.html
 == float-in-rtl-slr-1b.html float-in-rtl-slr-1-ref.html
 == float-in-rtl-slr-1c.html float-in-rtl-slr-1-ref.html
 == float-in-rtl-slr-1d.html float-in-rtl-slr-1-ref.html
 == float-in-rtl-slr-2a.html float-in-rtl-slr-2-ref.html
 == float-in-rtl-slr-2b.html float-in-rtl-slr-2-ref.html
 == float-in-rtl-slr-2c.html float-in-rtl-slr-2-ref.html
--- a/layout/style/nsCSSProps.cpp
+++ b/layout/style/nsCSSProps.cpp
@@ -754,17 +754,17 @@ const KTableEntry nsCSSProps::kCaptionSi
   { eCSSKeyword_right,                NS_STYLE_CAPTION_SIDE_RIGHT },
   { eCSSKeyword_bottom,               NS_STYLE_CAPTION_SIDE_BOTTOM },
   { eCSSKeyword_left,                 NS_STYLE_CAPTION_SIDE_LEFT },
   { eCSSKeyword_top_outside,          NS_STYLE_CAPTION_SIDE_TOP_OUTSIDE },
   { eCSSKeyword_bottom_outside,       NS_STYLE_CAPTION_SIDE_BOTTOM_OUTSIDE },
   { eCSSKeyword_UNKNOWN,              -1 }
 };
 
-KTableEntry nsCSSProps::kClearKTable[] = {
+const KTableEntry nsCSSProps::kClearKTable[] = {
   { eCSSKeyword_none, StyleClear::None },
   { eCSSKeyword_left, StyleClear::Left },
   { eCSSKeyword_right, StyleClear::Right },
   { eCSSKeyword_inline_start, StyleClear::InlineStart },
   { eCSSKeyword_inline_end, StyleClear::InlineEnd },
   { eCSSKeyword_both, StyleClear::Both },
   { eCSSKeyword_UNKNOWN, -1 }
 };
@@ -1186,17 +1186,17 @@ const KTableEntry nsCSSProps::kFlexWrapK
 
 const KTableEntry nsCSSProps::kHyphensKTable[] = {
   { eCSSKeyword_none, StyleHyphens::None },
   { eCSSKeyword_manual, StyleHyphens::Manual },
   { eCSSKeyword_auto, StyleHyphens::Auto },
   { eCSSKeyword_UNKNOWN, -1 }
 };
 
-KTableEntry nsCSSProps::kFloatKTable[] = {
+const KTableEntry nsCSSProps::kFloatKTable[] = {
   { eCSSKeyword_none, StyleFloat::None },
   { eCSSKeyword_left, StyleFloat::Left },
   { eCSSKeyword_right, StyleFloat::Right },
   { eCSSKeyword_inline_start, StyleFloat::InlineStart },
   { eCSSKeyword_inline_end, StyleFloat::InlineEnd },
   { eCSSKeyword_UNKNOWN, -1 }
 };
 
--- a/layout/style/nsCSSProps.h
+++ b/layout/style/nsCSSProps.h
@@ -547,19 +547,17 @@ public:
   static const KTableEntry kColorAdjustKTable[];
   static const KTableEntry kColorInterpolationKTable[];
   static const KTableEntry kColumnFillKTable[];
   static const KTableEntry kColumnSpanKTable[];
   static const KTableEntry kBoxPropSourceKTable[];
   static const KTableEntry kBoxShadowTypeKTable[];
   static const KTableEntry kBoxSizingKTable[];
   static const KTableEntry kCaptionSideKTable[];
-  // Not const because we modify its entries when the pref
-  // "layout.css.float-logical-values.enabled" changes:
-  static KTableEntry kClearKTable[];
+  static const KTableEntry kClearKTable[];
   static const KTableEntry kColorKTable[];
   static const KTableEntry kContentKTable[];
   static const KTableEntry kControlCharacterVisibilityKTable[];
   static const KTableEntry kCursorKTable[];
   static const KTableEntry kDirectionKTable[];
   // Not const because we modify its entries when various
   // "layout.css.*.enabled" prefs changes:
   static KTableEntry kDisplayKTable[];
@@ -578,19 +576,17 @@ public:
   static const KTableEntry kAlignContentPosition[]; // <content-position>
   // -- tables for auto-completion of the {align,justify}-{content,items,self} properties --
   static const KTableEntry kAutoCompletionAlignJustifySelf[];
   static const KTableEntry kAutoCompletionAlignItems[];
   static const KTableEntry kAutoCompletionAlignJustifyContent[];
   // ------------------------------------------------------------------
   static const KTableEntry kFlexDirectionKTable[];
   static const KTableEntry kFlexWrapKTable[];
-  // Not const because we modify its entries when the pref
-  // "layout.css.float-logical-values.enabled" changes:
-  static KTableEntry kFloatKTable[];
+  static const KTableEntry kFloatKTable[];
   static const KTableEntry kFloatEdgeKTable[];
   static const KTableEntry kFontDisplayKTable[];
   static const KTableEntry kFontKTable[];
   static const KTableEntry kFontKerningKTable[];
   static const KTableEntry kFontOpticalSizingKTable[];
   static const KTableEntry kFontSizeKTable[];
   static const KTableEntry kFontSmoothingKTable[];
   static const KTableEntry kFontStretchKTable[];
--- a/layout/style/test/property_database.js
+++ b/layout/style/test/property_database.js
@@ -3315,17 +3315,17 @@ var gCSSProperties = {
     other_values: [ "green", "transparent", "rgba(128,128,128,.5)", "#123" ],
     invalid_values: [ "#0", "#00", "#00000", "cc00ff" ]
   },
   "clear": {
     domProp: "clear",
     inherited: false,
     type: CSS_TYPE_LONGHAND,
     initial_values: [ "none" ],
-    other_values: [ "left", "right", "both" ],
+    other_values: [ "left", "right", "both", "inline-start", "inline-end" ],
     invalid_values: []
   },
   "clip": {
     domProp: "clip",
     inherited: false,
     type: CSS_TYPE_LONGHAND,
     initial_values: [ "auto" ],
     other_values: [ "rect(0 0 0 0)", "rect(auto,auto,auto,auto)", "rect(3px, 4px, 4em, 0)", "rect(auto, 3em, 4pt, 2px)", "rect(2px 3px 4px 5px)" ],
@@ -3475,17 +3475,17 @@ var gCSSProperties = {
     invalid_values: []
   },
   "float": {
     domProp: "cssFloat",
     inherited: false,
     type: CSS_TYPE_LONGHAND,
     applies_to_first_letter: true,
     initial_values: [ "none" ],
-    other_values: [ "left", "right" ],
+    other_values: [ "left", "right", "inline-start", "inline-end" ],
     invalid_values: []
   },
   "font": {
     domProp: "font",
     inherited: true,
     type: CSS_TYPE_TRUE_SHORTHAND,
     prerequisites: { "writing-mode": "initial" },
     subproperties: [ "font-style", "font-variant", "font-weight", "font-size", "line-height", "font-family", "font-stretch",
@@ -8127,28 +8127,16 @@ if (IsCSSPropertyPrefEnabled("layout.css
 }
 
 if (IsCSSPropertyPrefEnabled("layout.css.text-align-unsafe-value.enabled")) {
   gCSSProperties["text-align"].other_values.push("true left");
 } else {
   gCSSProperties["text-align"].invalid_values.push("true left");
 }
 
-if (IsCSSPropertyPrefEnabled("layout.css.float-logical-values.enabled")) {
-  gCSSProperties["float"].other_values.push("inline-start");
-  gCSSProperties["float"].other_values.push("inline-end");
-  gCSSProperties["clear"].other_values.push("inline-start");
-  gCSSProperties["clear"].other_values.push("inline-end");
-} else {
-  gCSSProperties["float"].invalid_values.push("inline-start");
-  gCSSProperties["float"].invalid_values.push("inline-end");
-  gCSSProperties["clear"].invalid_values.push("inline-start");
-  gCSSProperties["clear"].invalid_values.push("inline-end");
-}
-
 gCSSProperties["display"].other_values.push("flow-root");
 
 // Copy aliased properties' fields from their alias targets.
 for (var prop in gCSSProperties) {
   var entry = gCSSProperties[prop];
   if (entry.alias_for) {
     var aliasTargetEntry = gCSSProperties[entry.alias_for];
     if (!aliasTargetEntry) {
--- a/modules/libpref/init/all.js
+++ b/modules/libpref/init/all.js
@@ -2873,20 +2873,16 @@ pref("layout.css.convertFromNode.enabled
 #endif
 
 // Is support for CSS "text-align: unsafe X" enabled?
 pref("layout.css.text-align-unsafe-value.enabled", false);
 
 // Is support for CSS text-justify property enabled?
 pref("layout.css.text-justify.enabled", true);
 
-// Is support for CSS "float: inline-{start,end}" and
-// "clear: inline-{start,end}" enabled?
-pref("layout.css.float-logical-values.enabled", true);
-
 // Is support for the CSS4 image-orientation property enabled?
 pref("layout.css.image-orientation.enabled", true);
 
 // Is the paint-order property supported for HTML text?
 // (It is always supported for SVG.)
 pref("layout.css.paint-order.enabled", true);
 
 // Are sets of prefixed properties supported?
deleted file mode 100644
--- a/servo/components/style/gecko/generated/atom_macro.rs
+++ /dev/null
@@ -1,20907 +0,0 @@
-/* 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/. */
-
-/* Autogenerated file created by components/style/gecko/binding_tools/regen_atoms.py, DO NOT EDIT DIRECTLY */
-
-use gecko_bindings::structs::nsStaticAtom;
-use string_cache::Atom;
-
-pub enum nsICSSPseudoElement {}
-
-pub enum nsICSSAnonBoxPseudo {}
-
-#[inline(always)]
-pub unsafe fn atom_from_static(ptr: *mut nsStaticAtom) -> Atom {
-    Atom::from_static(ptr)
-}
-
-
-cfg_if! {
-    if #[cfg(not(target_env = "msvc"))] {
-        extern {
-            #[link_name = "_ZN9nsGkAtoms6_emptyE"]
-            pub static nsGkAtoms__empty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3mozE"]
-            pub static nsGkAtoms_moz: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12mozframetypeE"]
-            pub static nsGkAtoms_mozframetype: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11_moz_absposE"]
-            pub static nsGkAtoms__moz_abspos: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14_moz_activatedE"]
-            pub static nsGkAtoms__moz_activated: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14_moz_anonclassE"]
-            pub static nsGkAtoms__moz_anonclass: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13_moz_resizingE"]
-            pub static nsGkAtoms__moz_resizing: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18mozallowfullscreenE"]
-            pub static nsGkAtoms_mozallowfullscreen: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7moztypeE"]
-            pub static nsGkAtoms_moztype: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8mozdirtyE"]
-            pub static nsGkAtoms_mozdirty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms25mozdisallowselectionprintE"]
-            pub static nsGkAtoms_mozdisallowselectionprint: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12mozdonotsendE"]
-            pub static nsGkAtoms_mozdonotsend: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18mozeditorbogusnodeE"]
-            pub static nsGkAtoms_mozeditorbogusnode: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms25mozgeneratedcontentbeforeE"]
-            pub static nsGkAtoms_mozgeneratedcontentbefore: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24mozgeneratedcontentafterE"]
-            pub static nsGkAtoms_mozgeneratedcontentafter: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24mozgeneratedcontentimageE"]
-            pub static nsGkAtoms_mozgeneratedcontentimage: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8mozquoteE"]
-            pub static nsGkAtoms_mozquote: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12mozsignatureE"]
-            pub static nsGkAtoms_mozsignature: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13_moz_is_glyphE"]
-            pub static nsGkAtoms__moz_is_glyph: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18_moz_original_sizeE"]
-            pub static nsGkAtoms__moz_original_size: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11_moz_targetE"]
-            pub static nsGkAtoms__moz_target: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10menuactiveE"]
-            pub static nsGkAtoms_menuactive: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13_poundDefaultE"]
-            pub static nsGkAtoms__poundDefault: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9_asteriskE"]
-            pub static nsGkAtoms__asterisk: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms1aE"]
-            pub static nsGkAtoms_a: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4abbrE"]
-            pub static nsGkAtoms_abbr: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5abortE"]
-            pub static nsGkAtoms_abort: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5aboveE"]
-            pub static nsGkAtoms_above: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9acceltextE"]
-            pub static nsGkAtoms_acceltext: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6acceptE"]
-            pub static nsGkAtoms_accept: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13acceptcharsetE"]
-            pub static nsGkAtoms_acceptcharset: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9accesskeyE"]
-            pub static nsGkAtoms_accesskey: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7acronymE"]
-            pub static nsGkAtoms_acronym: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6actionE"]
-            pub static nsGkAtoms_action: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6activeE"]
-            pub static nsGkAtoms_active: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13activateontabE"]
-            pub static nsGkAtoms_activateontab: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7actuateE"]
-            pub static nsGkAtoms_actuate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7addressE"]
-            pub static nsGkAtoms_address: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5afterE"]
-            pub static nsGkAtoms_after: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9after_endE"]
-            pub static nsGkAtoms_after_end: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11after_startE"]
-            pub static nsGkAtoms_after_start: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5alignE"]
-            pub static nsGkAtoms_align: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5alinkE"]
-            pub static nsGkAtoms_alink: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3allE"]
-            pub static nsGkAtoms_all: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9allowdirsE"]
-            pub static nsGkAtoms_allowdirs: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11alloweventsE"]
-            pub static nsGkAtoms_allowevents: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms23allownegativeassertionsE"]
-            pub static nsGkAtoms_allownegativeassertions: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10allowformsE"]
-            pub static nsGkAtoms_allowforms: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15allowfullscreenE"]
-            pub static nsGkAtoms_allowfullscreen: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11allowmodalsE"]
-            pub static nsGkAtoms_allowmodals: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20alloworientationlockE"]
-            pub static nsGkAtoms_alloworientationlock: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19allowpaymentrequestE"]
-            pub static nsGkAtoms_allowpaymentrequest: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16allowpointerlockE"]
-            pub static nsGkAtoms_allowpointerlock: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms26allowpopupstoescapesandboxE"]
-            pub static nsGkAtoms_allowpopupstoescapesandbox: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11allowpopupsE"]
-            pub static nsGkAtoms_allowpopups: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17allowpresentationE"]
-            pub static nsGkAtoms_allowpresentation: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15allowsameoriginE"]
-            pub static nsGkAtoms_allowsameorigin: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12allowscriptsE"]
-            pub static nsGkAtoms_allowscripts: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18allowtopnavigationE"]
-            pub static nsGkAtoms_allowtopnavigation: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14allowuntrustedE"]
-            pub static nsGkAtoms_allowuntrusted: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3altE"]
-            pub static nsGkAtoms_alt: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9alternateE"]
-            pub static nsGkAtoms_alternate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6alwaysE"]
-            pub static nsGkAtoms_always: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8ancestorE"]
-            pub static nsGkAtoms_ancestor: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14ancestorOrSelfE"]
-            pub static nsGkAtoms_ancestorOrSelf: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6anchorE"]
-            pub static nsGkAtoms_anchor: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4_andE"]
-            pub static nsGkAtoms__and: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10animationsE"]
-            pub static nsGkAtoms_animations: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6anonidE"]
-            pub static nsGkAtoms_anonid: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12anonlocationE"]
-            pub static nsGkAtoms_anonlocation: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3anyE"]
-            pub static nsGkAtoms_any: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6appletE"]
-            pub static nsGkAtoms_applet: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12applyImportsE"]
-            pub static nsGkAtoms_applyImports: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14applyTemplatesE"]
-            pub static nsGkAtoms_applyTemplates: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7archiveE"]
-            pub static nsGkAtoms_archive: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4areaE"]
-            pub static nsGkAtoms_area: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21aria_activedescendantE"]
-            pub static nsGkAtoms_aria_activedescendant: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11aria_atomicE"]
-            pub static nsGkAtoms_aria_atomic: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17aria_autocompleteE"]
-            pub static nsGkAtoms_aria_autocomplete: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9aria_busyE"]
-            pub static nsGkAtoms_aria_busy: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12aria_checkedE"]
-            pub static nsGkAtoms_aria_checked: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13aria_controlsE"]
-            pub static nsGkAtoms_aria_controls: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12aria_currentE"]
-            pub static nsGkAtoms_aria_current: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16aria_describedbyE"]
-            pub static nsGkAtoms_aria_describedby: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13aria_disabledE"]
-            pub static nsGkAtoms_aria_disabled: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15aria_dropeffectE"]
-            pub static nsGkAtoms_aria_dropeffect: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13aria_expandedE"]
-            pub static nsGkAtoms_aria_expanded: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11aria_flowtoE"]
-            pub static nsGkAtoms_aria_flowto: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13aria_haspopupE"]
-            pub static nsGkAtoms_aria_haspopup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11aria_hiddenE"]
-            pub static nsGkAtoms_aria_hidden: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12aria_invalidE"]
-            pub static nsGkAtoms_aria_invalid: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15aria_labelledbyE"]
-            pub static nsGkAtoms_aria_labelledby: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10aria_levelE"]
-            pub static nsGkAtoms_aria_level: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9aria_liveE"]
-            pub static nsGkAtoms_aria_live: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14aria_multilineE"]
-            pub static nsGkAtoms_aria_multiline: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20aria_multiselectableE"]
-            pub static nsGkAtoms_aria_multiselectable: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9aria_ownsE"]
-            pub static nsGkAtoms_aria_owns: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13aria_posinsetE"]
-            pub static nsGkAtoms_aria_posinset: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12aria_pressedE"]
-            pub static nsGkAtoms_aria_pressed: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13aria_readonlyE"]
-            pub static nsGkAtoms_aria_readonly: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13aria_relevantE"]
-            pub static nsGkAtoms_aria_relevant: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13aria_requiredE"]
-            pub static nsGkAtoms_aria_required: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13aria_selectedE"]
-            pub static nsGkAtoms_aria_selected: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12aria_setsizeE"]
-            pub static nsGkAtoms_aria_setsize: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9aria_sortE"]
-            pub static nsGkAtoms_aria_sort: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13aria_valuemaxE"]
-            pub static nsGkAtoms_aria_valuemax: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13aria_valueminE"]
-            pub static nsGkAtoms_aria_valuemin: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13aria_valuenowE"]
-            pub static nsGkAtoms_aria_valuenow: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5arrowE"]
-            pub static nsGkAtoms_arrow: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7articleE"]
-            pub static nsGkAtoms_article: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2asE"]
-            pub static nsGkAtoms_as: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9ascendingE"]
-            pub static nsGkAtoms_ascending: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5asideE"]
-            pub static nsGkAtoms_aside: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11aspectRatioE"]
-            pub static nsGkAtoms_aspectRatio: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6assignE"]
-            pub static nsGkAtoms_assign: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5asyncE"]
-            pub static nsGkAtoms_async: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9attributeE"]
-            pub static nsGkAtoms_attribute: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10attributesE"]
-            pub static nsGkAtoms_attributes: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12attributeSetE"]
-            pub static nsGkAtoms_attributeSet: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5auralE"]
-            pub static nsGkAtoms_aural: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5_autoE"]
-            pub static nsGkAtoms__auto: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9autocheckE"]
-            pub static nsGkAtoms_autocheck: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12autocompleteE"]
-            pub static nsGkAtoms_autocomplete: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24autocomplete_richlistboxE"]
-            pub static nsGkAtoms_autocomplete_richlistbox: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9autofocusE"]
-            pub static nsGkAtoms_autofocus: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8autoplayE"]
-            pub static nsGkAtoms_autoplay: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16autorepeatbuttonE"]
-            pub static nsGkAtoms_autorepeatbutton: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4axisE"]
-            pub static nsGkAtoms_axis: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms1bE"]
-            pub static nsGkAtoms_b: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10backgroundE"]
-            pub static nsGkAtoms_background: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4baseE"]
-            pub static nsGkAtoms_base: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8basefontE"]
-            pub static nsGkAtoms_basefont: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8baselineE"]
-            pub static nsGkAtoms_baseline: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3bdiE"]
-            pub static nsGkAtoms_bdi: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3bdoE"]
-            pub static nsGkAtoms_bdo: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6beforeE"]
-            pub static nsGkAtoms_before: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10before_endE"]
-            pub static nsGkAtoms_before_end: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12before_startE"]
-            pub static nsGkAtoms_before_start: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5belowE"]
-            pub static nsGkAtoms_below: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7bgcolorE"]
-            pub static nsGkAtoms_bgcolor: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7bgsoundE"]
-            pub static nsGkAtoms_bgsound: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3bigE"]
-            pub static nsGkAtoms_big: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7bindingE"]
-            pub static nsGkAtoms_binding: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8bindingsE"]
-            pub static nsGkAtoms_bindings: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms22bindToUntrustedContentE"]
-            pub static nsGkAtoms_bindToUntrustedContent: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8blankrowE"]
-            pub static nsGkAtoms_blankrow: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5blockE"]
-            pub static nsGkAtoms_block: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10blockquoteE"]
-            pub static nsGkAtoms_blockquote: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4blurE"]
-            pub static nsGkAtoms_blur: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4bodyE"]
-            pub static nsGkAtoms_body: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7booleanE"]
-            pub static nsGkAtoms_boolean: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6borderE"]
-            pub static nsGkAtoms_border: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11bordercolorE"]
-            pub static nsGkAtoms_bordercolor: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4bothE"]
-            pub static nsGkAtoms_both: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6bottomE"]
-            pub static nsGkAtoms_bottom: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9bottomendE"]
-            pub static nsGkAtoms_bottomend: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11bottomstartE"]
-            pub static nsGkAtoms_bottomstart: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10bottomleftE"]
-            pub static nsGkAtoms_bottomleft: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12bottommarginE"]
-            pub static nsGkAtoms_bottommargin: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13bottompaddingE"]
-            pub static nsGkAtoms_bottompadding: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11bottomrightE"]
-            pub static nsGkAtoms_bottomright: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3boxE"]
-            pub static nsGkAtoms_box: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2brE"]
-            pub static nsGkAtoms_br: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7brailleE"]
-            pub static nsGkAtoms_braille: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9broadcastE"]
-            pub static nsGkAtoms_broadcast: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11broadcasterE"]
-            pub static nsGkAtoms_broadcaster: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14broadcastersetE"]
-            pub static nsGkAtoms_broadcasterset: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7browserE"]
-            pub static nsGkAtoms_browser: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10mozbrowserE"]
-            pub static nsGkAtoms_mozbrowser: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6buttonE"]
-            pub static nsGkAtoms_button: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24brighttitlebarforegroundE"]
-            pub static nsGkAtoms_brighttitlebarforeground: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12callTemplateE"]
-            pub static nsGkAtoms_callTemplate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6cancelE"]
-            pub static nsGkAtoms_cancel: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6canvasE"]
-            pub static nsGkAtoms_canvas: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7captionE"]
-            pub static nsGkAtoms_caption: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7captureE"]
-            pub static nsGkAtoms_capture: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9caseOrderE"]
-            pub static nsGkAtoms_caseOrder: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20cdataSectionElementsE"]
-            pub static nsGkAtoms_cdataSectionElements: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7ceilingE"]
-            pub static nsGkAtoms_ceiling: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4cellE"]
-            pub static nsGkAtoms_cell: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11cellpaddingE"]
-            pub static nsGkAtoms_cellpadding: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11cellspacingE"]
-            pub static nsGkAtoms_cellspacing: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6centerE"]
-            pub static nsGkAtoms_center: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2chE"]
-            pub static nsGkAtoms_ch: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6changeE"]
-            pub static nsGkAtoms_change: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5_charE"]
-            pub static nsGkAtoms__char: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13characterDataE"]
-            pub static nsGkAtoms_characterData: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8charcodeE"]
-            pub static nsGkAtoms_charcode: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7charoffE"]
-            pub static nsGkAtoms_charoff: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7charsetE"]
-            pub static nsGkAtoms_charset: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8checkboxE"]
-            pub static nsGkAtoms_checkbox: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7checkedE"]
-            pub static nsGkAtoms_checked: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5childE"]
-            pub static nsGkAtoms_child: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8childrenE"]
-            pub static nsGkAtoms_children: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9childListE"]
-            pub static nsGkAtoms_childList: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6chooseE"]
-            pub static nsGkAtoms_choose: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12chromemarginE"]
-            pub static nsGkAtoms_chromemargin: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17chromeOnlyContentE"]
-            pub static nsGkAtoms_chromeOnlyContent: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24exposeToUntrustedContentE"]
-            pub static nsGkAtoms_exposeToUntrustedContent: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4circE"]
-            pub static nsGkAtoms_circ: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6circleE"]
-            pub static nsGkAtoms_circle: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4citeE"]
-            pub static nsGkAtoms_cite: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10cjkDecimalE"]
-            pub static nsGkAtoms_cjkDecimal: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6_classE"]
-            pub static nsGkAtoms__class: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7classidE"]
-            pub static nsGkAtoms_classid: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5clearE"]
-            pub static nsGkAtoms_clear: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5clickE"]
-            pub static nsGkAtoms_click: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10clickcountE"]
-            pub static nsGkAtoms_clickcount: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12clickthroughE"]
-            pub static nsGkAtoms_clickthrough: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11movetoclickE"]
-            pub static nsGkAtoms_movetoclick: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4clipE"]
-            pub static nsGkAtoms_clip: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5closeE"]
-            pub static nsGkAtoms_close: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6closedE"]
-            pub static nsGkAtoms_closed: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9closemenuE"]
-            pub static nsGkAtoms_closemenu: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21coalesceduplicatearcsE"]
-            pub static nsGkAtoms_coalesceduplicatearcs: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4codeE"]
-            pub static nsGkAtoms_code: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8codebaseE"]
-            pub static nsGkAtoms_codebase: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8codetypeE"]
-            pub static nsGkAtoms_codetype: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3colE"]
-            pub static nsGkAtoms_col: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8colgroupE"]
-            pub static nsGkAtoms_colgroup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8collapseE"]
-            pub static nsGkAtoms_collapse: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9collapsedE"]
-            pub static nsGkAtoms_collapsed: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5colorE"]
-            pub static nsGkAtoms_color: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10colorIndexE"]
-            pub static nsGkAtoms_colorIndex: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4colsE"]
-            pub static nsGkAtoms_cols: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7colspanE"]
-            pub static nsGkAtoms_colspan: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6columnE"]
-            pub static nsGkAtoms_column: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7columnsE"]
-            pub static nsGkAtoms_columns: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8comboboxE"]
-            pub static nsGkAtoms_combobox: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7commandE"]
-            pub static nsGkAtoms_command: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8commandsE"]
-            pub static nsGkAtoms_commands: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10commandsetE"]
-            pub static nsGkAtoms_commandset: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13commandupdateE"]
-            pub static nsGkAtoms_commandupdate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14commandupdaterE"]
-            pub static nsGkAtoms_commandupdater: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7commentE"]
-            pub static nsGkAtoms_comment: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7compactE"]
-            pub static nsGkAtoms_compact: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6concatE"]
-            pub static nsGkAtoms_concat: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10conditionsE"]
-            pub static nsGkAtoms_conditions: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11constructorE"]
-            pub static nsGkAtoms_constructor: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20consumeoutsideclicksE"]
-            pub static nsGkAtoms_consumeoutsideclicks: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9containerE"]
-            pub static nsGkAtoms_container: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11containmentE"]
-            pub static nsGkAtoms_containment: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8containsE"]
-            pub static nsGkAtoms_contains: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7contentE"]
-            pub static nsGkAtoms_content: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15contenteditableE"]
-            pub static nsGkAtoms_contenteditable: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24headerContentDispositionE"]
-            pub static nsGkAtoms_headerContentDisposition: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21headerContentLanguageE"]
-            pub static nsGkAtoms_headerContentLanguage: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15contentLocationE"]
-            pub static nsGkAtoms_contentLocation: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms23headerContentScriptTypeE"]
-            pub static nsGkAtoms_headerContentScriptType: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms22headerContentStyleTypeE"]
-            pub static nsGkAtoms_headerContentStyleType: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17headerContentTypeE"]
-            pub static nsGkAtoms_headerContentType: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13consumeanchorE"]
-            pub static nsGkAtoms_consumeanchor: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7contextE"]
-            pub static nsGkAtoms_context: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11contextmenuE"]
-            pub static nsGkAtoms_contextmenu: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7controlE"]
-            pub static nsGkAtoms_control: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8controlsE"]
-            pub static nsGkAtoms_controls: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6coordsE"]
-            pub static nsGkAtoms_coords: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4copyE"]
-            pub static nsGkAtoms_copy: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6copyOfE"]
-            pub static nsGkAtoms_copyOf: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5countE"]
-            pub static nsGkAtoms_count: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4cropE"]
-            pub static nsGkAtoms_crop: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11crossoriginE"]
-            pub static nsGkAtoms_crossorigin: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6curposE"]
-            pub static nsGkAtoms_curpos: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7currentE"]
-            pub static nsGkAtoms_current: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12cutoutregionE"]
-            pub static nsGkAtoms_cutoutregion: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6cyclerE"]
-            pub static nsGkAtoms_cycler: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4dataE"]
-            pub static nsGkAtoms_data: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8datalistE"]
-            pub static nsGkAtoms_datalist: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10datal10nidE"]
-            pub static nsGkAtoms_datal10nid: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12datal10nargsE"]
-            pub static nsGkAtoms_datal10nargs: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13datal10nattrsE"]
-            pub static nsGkAtoms_datal10nattrs: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8dataTypeE"]
-            pub static nsGkAtoms_dataType: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8dateTimeE"]
-            pub static nsGkAtoms_dateTime: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11datasourcesE"]
-            pub static nsGkAtoms_datasources: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4dateE"]
-            pub static nsGkAtoms_date: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8datetimeE"]
-            pub static nsGkAtoms_datetime: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11datetimeboxE"]
-            pub static nsGkAtoms_datetimebox: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8dblclickE"]
-            pub static nsGkAtoms_dblclick: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2ddE"]
-            pub static nsGkAtoms_dd: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5debugE"]
-            pub static nsGkAtoms_debug: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7decimalE"]
-            pub static nsGkAtoms_decimal: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13decimalFormatE"]
-            pub static nsGkAtoms_decimalFormat: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16decimalSeparatorE"]
-            pub static nsGkAtoms_decimalSeparator: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4deckE"]
-            pub static nsGkAtoms_deck: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7declareE"]
-            pub static nsGkAtoms_declare: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13decoderDoctorE"]
-            pub static nsGkAtoms_decoderDoctor: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9decrementE"]
-            pub static nsGkAtoms_decrement: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8_defaultE"]
-            pub static nsGkAtoms__default: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18headerDefaultStyleE"]
-            pub static nsGkAtoms_headerDefaultStyle: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13defaultActionE"]
-            pub static nsGkAtoms_defaultAction: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14defaultcheckedE"]
-            pub static nsGkAtoms_defaultchecked: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12defaultLabelE"]
-            pub static nsGkAtoms_defaultLabel: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15defaultselectedE"]
-            pub static nsGkAtoms_defaultselected: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12defaultvalueE"]
-            pub static nsGkAtoms_defaultvalue: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19defaultplaybackrateE"]
-            pub static nsGkAtoms_defaultplaybackrate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5deferE"]
-            pub static nsGkAtoms_defer: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3delE"]
-            pub static nsGkAtoms_del: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10descendantE"]
-            pub static nsGkAtoms_descendant: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16descendantOrSelfE"]
-            pub static nsGkAtoms_descendantOrSelf: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10descendingE"]
-            pub static nsGkAtoms_descending: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11descriptionE"]
-            pub static nsGkAtoms_description: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10destructorE"]
-            pub static nsGkAtoms_destructor: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7detailsE"]
-            pub static nsGkAtoms_details: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17deviceAspectRatioE"]
-            pub static nsGkAtoms_deviceAspectRatio: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12deviceHeightE"]
-            pub static nsGkAtoms_deviceHeight: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16devicePixelRatioE"]
-            pub static nsGkAtoms_devicePixelRatio: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11deviceWidthE"]
-            pub static nsGkAtoms_deviceWidth: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3dfnE"]
-            pub static nsGkAtoms_dfn: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6dialogE"]
-            pub static nsGkAtoms_dialog: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10differenceE"]
-            pub static nsGkAtoms_difference: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5digitE"]
-            pub static nsGkAtoms_digit: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3dirE"]
-            pub static nsGkAtoms_dir: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12dirAutoSetByE"]
-            pub static nsGkAtoms_dirAutoSetBy: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14directionalityE"]
-            pub static nsGkAtoms_directionality: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9directoryE"]
-            pub static nsGkAtoms_directory: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21disableOutputEscapingE"]
-            pub static nsGkAtoms_disableOutputEscaping: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8disabledE"]
-            pub static nsGkAtoms_disabled: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20disableglobalhistoryE"]
-            pub static nsGkAtoms_disableglobalhistory: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14disablehistoryE"]
-            pub static nsGkAtoms_disablehistory: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17disablefullscreenE"]
-            pub static nsGkAtoms_disablefullscreen: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17disclosure_closedE"]
-            pub static nsGkAtoms_disclosure_closed: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15disclosure_openE"]
-            pub static nsGkAtoms_disclosure_open: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7displayE"]
-            pub static nsGkAtoms_display: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11displayModeE"]
-            pub static nsGkAtoms_displayMode: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8distinctE"]
-            pub static nsGkAtoms_distinct: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3divE"]
-            pub static nsGkAtoms_div: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2dlE"]
-            pub static nsGkAtoms_dl: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11docAbstractE"]
-            pub static nsGkAtoms_docAbstract: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18docAcknowledgmentsE"]
-            pub static nsGkAtoms_docAcknowledgments: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12docAfterwordE"]
-            pub static nsGkAtoms_docAfterword: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11docAppendixE"]
-            pub static nsGkAtoms_docAppendix: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11docBacklinkE"]
-            pub static nsGkAtoms_docBacklink: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14docBiblioentryE"]
-            pub static nsGkAtoms_docBiblioentry: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15docBibliographyE"]
-            pub static nsGkAtoms_docBibliography: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12docBibliorefE"]
-            pub static nsGkAtoms_docBiblioref: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10docChapterE"]
-            pub static nsGkAtoms_docChapter: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11docColophonE"]
-            pub static nsGkAtoms_docColophon: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13docConclusionE"]
-            pub static nsGkAtoms_docConclusion: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8docCoverE"]
-            pub static nsGkAtoms_docCover: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9docCreditE"]
-            pub static nsGkAtoms_docCredit: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10docCreditsE"]
-            pub static nsGkAtoms_docCredits: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13docDedicationE"]
-            pub static nsGkAtoms_docDedication: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10docEndnoteE"]
-            pub static nsGkAtoms_docEndnote: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11docEndnotesE"]
-            pub static nsGkAtoms_docEndnotes: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11docEpigraphE"]
-            pub static nsGkAtoms_docEpigraph: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11docEpilogueE"]
-            pub static nsGkAtoms_docEpilogue: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9docErrataE"]
-            pub static nsGkAtoms_docErrata: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10docExampleE"]
-            pub static nsGkAtoms_docExample: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11docFootnoteE"]
-            pub static nsGkAtoms_docFootnote: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11docForewordE"]
-            pub static nsGkAtoms_docForeword: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11docGlossaryE"]
-            pub static nsGkAtoms_docGlossary: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11docGlossrefE"]
-            pub static nsGkAtoms_docGlossref: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8docIndexE"]
-            pub static nsGkAtoms_docIndex: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15docIntroductionE"]
-            pub static nsGkAtoms_docIntroduction: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10docNoterefE"]
-            pub static nsGkAtoms_docNoteref: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9docNoticeE"]
-            pub static nsGkAtoms_docNotice: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12docPagebreakE"]
-            pub static nsGkAtoms_docPagebreak: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11docPagelistE"]
-            pub static nsGkAtoms_docPagelist: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7docPartE"]
-            pub static nsGkAtoms_docPart: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10docPrefaceE"]
-            pub static nsGkAtoms_docPreface: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11docPrologueE"]
-            pub static nsGkAtoms_docPrologue: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12docPullquoteE"]
-            pub static nsGkAtoms_docPullquote: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6docQnaE"]
-            pub static nsGkAtoms_docQna: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11docSubtitleE"]
-            pub static nsGkAtoms_docSubtitle: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6docTipE"]
-            pub static nsGkAtoms_docTip: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6docTocE"]
-            pub static nsGkAtoms_docToc: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13doctypePublicE"]
-            pub static nsGkAtoms_doctypePublic: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13doctypeSystemE"]
-            pub static nsGkAtoms_doctypeSystem: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8documentE"]
-            pub static nsGkAtoms_document: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8downloadE"]
-            pub static nsGkAtoms_download: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15DOMAttrModifiedE"]
-            pub static nsGkAtoms_DOMAttrModified: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24DOMCharacterDataModifiedE"]
-            pub static nsGkAtoms_DOMCharacterDataModified: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15DOMNodeInsertedE"]
-            pub static nsGkAtoms_DOMNodeInserted: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms27DOMNodeInsertedIntoDocumentE"]
-            pub static nsGkAtoms_DOMNodeInsertedIntoDocument: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14DOMNodeRemovedE"]
-            pub static nsGkAtoms_DOMNodeRemoved: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms26DOMNodeRemovedFromDocumentE"]
-            pub static nsGkAtoms_DOMNodeRemovedFromDocument: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18DOMSubtreeModifiedE"]
-            pub static nsGkAtoms_DOMSubtreeModified: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7double_E"]
-            pub static nsGkAtoms_double_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4dragE"]
-            pub static nsGkAtoms_drag: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7dragendE"]
-            pub static nsGkAtoms_dragend: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9dragenterE"]
-            pub static nsGkAtoms_dragenter: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9drageventE"]
-            pub static nsGkAtoms_dragevent: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8dragexitE"]
-            pub static nsGkAtoms_dragexit: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9draggableE"]
-            pub static nsGkAtoms_draggable: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8draggingE"]
-            pub static nsGkAtoms_dragging: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9dragleaveE"]
-            pub static nsGkAtoms_dragleave: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8dragoverE"]
-            pub static nsGkAtoms_dragover: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11dragSessionE"]
-            pub static nsGkAtoms_dragSession: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9dragstartE"]
-            pub static nsGkAtoms_dragstart: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14drawintitlebarE"]
-            pub static nsGkAtoms_drawintitlebar: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9drawtitleE"]
-            pub static nsGkAtoms_drawtitle: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4dropE"]
-            pub static nsGkAtoms_drop: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9dropAfterE"]
-            pub static nsGkAtoms_dropAfter: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10dropBeforeE"]
-            pub static nsGkAtoms_dropBefore: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6dropOnE"]
-            pub static nsGkAtoms_dropOn: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10dropMarkerE"]
-            pub static nsGkAtoms_dropMarker: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2dtE"]
-            pub static nsGkAtoms_dt: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8editableE"]
-            pub static nsGkAtoms_editable: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7editingE"]
-            pub static nsGkAtoms_editing: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6editorE"]
-            pub static nsGkAtoms_editor: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17editorDisplayListE"]
-            pub static nsGkAtoms_editorDisplayList: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7elementE"]
-            pub static nsGkAtoms_element: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16elementAvailableE"]
-            pub static nsGkAtoms_elementAvailable: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8elementsE"]
-            pub static nsGkAtoms_elements: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2emE"]
-            pub static nsGkAtoms_em: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5embedE"]
-            pub static nsGkAtoms_embed: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8embossedE"]
-            pub static nsGkAtoms_embossed: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5emptyE"]
-            pub static nsGkAtoms_empty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8encodingE"]
-            pub static nsGkAtoms_encoding: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7enctypeE"]
-            pub static nsGkAtoms_enctype: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3endE"]
-            pub static nsGkAtoms_end: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8endEventE"]
-            pub static nsGkAtoms_endEvent: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9end_afterE"]
-            pub static nsGkAtoms_end_after: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10end_beforeE"]
-            pub static nsGkAtoms_end_before: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9equalsizeE"]
-            pub static nsGkAtoms_equalsize: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5errorE"]
-            pub static nsGkAtoms_error: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16ethiopic_numericE"]
-            pub static nsGkAtoms_ethiopic_numeric: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4evenE"]
-            pub static nsGkAtoms_even: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5eventE"]
-            pub static nsGkAtoms_event: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6eventsE"]
-            pub static nsGkAtoms_events: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21excludeResultPrefixesE"]
-            pub static nsGkAtoms_excludeResultPrefixes: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8excludesE"]
-            pub static nsGkAtoms_excludes: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4exprE"]
-            pub static nsGkAtoms_expr: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7extendsE"]
-            pub static nsGkAtoms_extends: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24extensionElementPrefixesE"]
-            pub static nsGkAtoms_extensionElementPrefixes: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4faceE"]
-            pub static nsGkAtoms_face: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8fallbackE"]
-            pub static nsGkAtoms_fallback: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6_falseE"]
-            pub static nsGkAtoms__false: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8farthestE"]
-            pub static nsGkAtoms_farthest: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5fieldE"]
-            pub static nsGkAtoms_field: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8fieldsetE"]
-            pub static nsGkAtoms_fieldset: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4fileE"]
-            pub static nsGkAtoms_file: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10figcaptionE"]
-            pub static nsGkAtoms_figcaption: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6figureE"]
-            pub static nsGkAtoms_figure: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7findbarE"]
-            pub static nsGkAtoms_findbar: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5fixedE"]
-            pub static nsGkAtoms_fixed: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5flagsE"]
-            pub static nsGkAtoms_flags: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4flexE"]
-            pub static nsGkAtoms_flex: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9flexgroupE"]
-            pub static nsGkAtoms_flexgroup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4flipE"]
-            pub static nsGkAtoms_flip: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8floatingE"]
-            pub static nsGkAtoms_floating: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5floorE"]
-            pub static nsGkAtoms_floor: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10flowlengthE"]
-            pub static nsGkAtoms_flowlength: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5focusE"]
-            pub static nsGkAtoms_focus: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7focusedE"]
-            pub static nsGkAtoms_focused: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12followanchorE"]
-            pub static nsGkAtoms_followanchor: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9followingE"]
-            pub static nsGkAtoms_following: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16followingSiblingE"]
-            pub static nsGkAtoms_followingSibling: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4fontE"]
-            pub static nsGkAtoms_font: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10fontWeightE"]
-            pub static nsGkAtoms_fontWeight: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10fontpickerE"]
-            pub static nsGkAtoms_fontpicker: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6footerE"]
-            pub static nsGkAtoms_footer: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4_forE"]
-            pub static nsGkAtoms__for: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7forEachE"]
-            pub static nsGkAtoms_forEach: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21forceOwnRefreshDriverE"]
-            pub static nsGkAtoms_forceOwnRefreshDriver: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4formE"]
-            pub static nsGkAtoms_form: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10formactionE"]
-            pub static nsGkAtoms_formaction: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6formatE"]
-            pub static nsGkAtoms_format: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12formatNumberE"]
-            pub static nsGkAtoms_formatNumber: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11formenctypeE"]
-            pub static nsGkAtoms_formenctype: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10formmethodE"]
-            pub static nsGkAtoms_formmethod: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14formnovalidateE"]
-            pub static nsGkAtoms_formnovalidate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10formtargetE"]
-            pub static nsGkAtoms_formtarget: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5frameE"]
-            pub static nsGkAtoms_frame: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11frameborderE"]
-            pub static nsGkAtoms_frameborder: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8framesetE"]
-            pub static nsGkAtoms_frameset: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4fromE"]
-            pub static nsGkAtoms_from: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16fullscreenchangeE"]
-            pub static nsGkAtoms_fullscreenchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15fullscreenerrorE"]
-            pub static nsGkAtoms_fullscreenerror: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17functionAvailableE"]
-            pub static nsGkAtoms_functionAvailable: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12freshProcessE"]
-            pub static nsGkAtoms_freshProcess: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10generateIdE"]
-            pub static nsGkAtoms_generateId: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6getterE"]
-            pub static nsGkAtoms_getter: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9glyphcharE"]
-            pub static nsGkAtoms_glyphchar: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7glyphidE"]
-            pub static nsGkAtoms_glyphid: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16graphicsDocumentE"]
-            pub static nsGkAtoms_graphicsDocument: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14graphicsObjectE"]
-            pub static nsGkAtoms_graphicsObject: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14graphicsSymbolE"]
-            pub static nsGkAtoms_graphicsSymbol: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4gridE"]
-            pub static nsGkAtoms_grid: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5groupE"]
-            pub static nsGkAtoms_group: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8groupboxE"]
-            pub static nsGkAtoms_groupbox: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17groupingSeparatorE"]
-            pub static nsGkAtoms_groupingSeparator: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12groupingSizeE"]
-            pub static nsGkAtoms_groupingSize: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4growE"]
-            pub static nsGkAtoms_grow: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6gutterE"]
-            pub static nsGkAtoms_gutter: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2h1E"]
-            pub static nsGkAtoms_h1: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2h2E"]
-            pub static nsGkAtoms_h2: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2h3E"]
-            pub static nsGkAtoms_h3: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2h4E"]
-            pub static nsGkAtoms_h4: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2h5E"]
-            pub static nsGkAtoms_h5: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2h6E"]
-            pub static nsGkAtoms_h6: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8handheldE"]
-            pub static nsGkAtoms_handheld: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16handheldFriendlyE"]
-            pub static nsGkAtoms_handheldFriendly: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7handlerE"]
-            pub static nsGkAtoms_handler: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8handlersE"]
-            pub static nsGkAtoms_handlers: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4HARDE"]
-            pub static nsGkAtoms_HARD: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8haspopupE"]
-            pub static nsGkAtoms_haspopup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11hasSameNodeE"]
-            pub static nsGkAtoms_hasSameNode: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4hboxE"]
-            pub static nsGkAtoms_hbox: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4headE"]
-            pub static nsGkAtoms_head: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6headerE"]
-            pub static nsGkAtoms_header: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7headersE"]
-            pub static nsGkAtoms_headers: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6hebrewE"]
-            pub static nsGkAtoms_hebrew: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6heightE"]
-            pub static nsGkAtoms_height: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6hgroupE"]
-            pub static nsGkAtoms_hgroup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6hiddenE"]
-            pub static nsGkAtoms_hidden: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10hidechromeE"]
-            pub static nsGkAtoms_hidechrome: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16hidecolumnpickerE"]
-            pub static nsGkAtoms_hidecolumnpicker: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4highE"]
-            pub static nsGkAtoms_high: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7highestE"]
-            pub static nsGkAtoms_highest: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10horizontalE"]
-            pub static nsGkAtoms_horizontal: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5hoverE"]
-            pub static nsGkAtoms_hover: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2hrE"]
-            pub static nsGkAtoms_hr: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4hrefE"]
-            pub static nsGkAtoms_href: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8hreflangE"]
-            pub static nsGkAtoms_hreflang: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6hspaceE"]
-            pub static nsGkAtoms_hspace: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4htmlE"]
-            pub static nsGkAtoms_html: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9httpEquivE"]
-            pub static nsGkAtoms_httpEquiv: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms1iE"]
-            pub static nsGkAtoms_i: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4iconE"]
-            pub static nsGkAtoms_icon: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2idE"]
-            pub static nsGkAtoms_id: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3_ifE"]
-            pub static nsGkAtoms__if: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6iframeE"]
-            pub static nsGkAtoms_iframe: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10ignorecaseE"]
-            pub static nsGkAtoms_ignorecase: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10ignorekeysE"]
-            pub static nsGkAtoms_ignorekeys: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15ignoreuserfocusE"]
-            pub static nsGkAtoms_ignoreuserfocus: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6ilayerE"]
-            pub static nsGkAtoms_ilayer: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5imageE"]
-            pub static nsGkAtoms_image: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17imageClickedPointE"]
-            pub static nsGkAtoms_imageClickedPoint: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3imgE"]
-            pub static nsGkAtoms_img: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14implementationE"]
-            pub static nsGkAtoms_implementation: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10implementsE"]
-            pub static nsGkAtoms_implements: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6importE"]
-            pub static nsGkAtoms_import: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7includeE"]
-            pub static nsGkAtoms_include: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8includesE"]
-            pub static nsGkAtoms_includes: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9incrementE"]
-            pub static nsGkAtoms_increment: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6indentE"]
-            pub static nsGkAtoms_indent: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13indeterminateE"]
-            pub static nsGkAtoms_indeterminate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5indexE"]
-            pub static nsGkAtoms_index: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5inferE"]
-            pub static nsGkAtoms_infer: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8infinityE"]
-            pub static nsGkAtoms_infinity: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7inheritE"]
-            pub static nsGkAtoms_inherit: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8inheritsE"]
-            pub static nsGkAtoms_inherits: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12inheritstyleE"]
-            pub static nsGkAtoms_inheritstyle: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13initial_scaleE"]
-            pub static nsGkAtoms_initial_scale: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5inputE"]
-            pub static nsGkAtoms_input: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9inputmodeE"]
-            pub static nsGkAtoms_inputmode: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3insE"]
-            pub static nsGkAtoms_ins: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11insertafterE"]
-            pub static nsGkAtoms_insertafter: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12insertbeforeE"]
-            pub static nsGkAtoms_insertbefore: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7installE"]
-            pub static nsGkAtoms_install: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10instanceOfE"]
-            pub static nsGkAtoms_instanceOf: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5int32E"]
-            pub static nsGkAtoms_int32: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5int64E"]
-            pub static nsGkAtoms_int64: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7integerE"]
-            pub static nsGkAtoms_integer: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9integrityE"]
-            pub static nsGkAtoms_integrity: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12intersectionE"]
-            pub static nsGkAtoms_intersection: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24intersectionobserverlistE"]
-            pub static nsGkAtoms_intersectionobserverlist: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2isE"]
-            pub static nsGkAtoms_is: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11iscontainerE"]
-            pub static nsGkAtoms_iscontainer: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7isemptyE"]
-            pub static nsGkAtoms_isempty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5ismapE"]
-            pub static nsGkAtoms_ismap: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6itemidE"]
-            pub static nsGkAtoms_itemid: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8itempropE"]
-            pub static nsGkAtoms_itemprop: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7itemrefE"]
-            pub static nsGkAtoms_itemref: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9itemscopeE"]
-            pub static nsGkAtoms_itemscope: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8itemtypeE"]
-            pub static nsGkAtoms_itemtype: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15japanese_formalE"]
-            pub static nsGkAtoms_japanese_formal: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17japanese_informalE"]
-            pub static nsGkAtoms_japanese_informal: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3kbdE"]
-            pub static nsGkAtoms_kbd: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17keepcurrentinviewE"]
-            pub static nsGkAtoms_keepcurrentinview: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16keepobjectsaliveE"]
-            pub static nsGkAtoms_keepobjectsalive: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3keyE"]
-            pub static nsGkAtoms_key: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7keycodeE"]
-            pub static nsGkAtoms_keycode: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17keystatuseschangeE"]
-            pub static nsGkAtoms_keystatuseschange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7keydownE"]
-            pub static nsGkAtoms_keydown: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6keygenE"]
-            pub static nsGkAtoms_keygen: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8keypressE"]
-            pub static nsGkAtoms_keypress: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6keysetE"]
-            pub static nsGkAtoms_keyset: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9keysystemE"]
-            pub static nsGkAtoms_keysystem: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7keytextE"]
-            pub static nsGkAtoms_keytext: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5keyupE"]
-            pub static nsGkAtoms_keyup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4kindE"]
-            pub static nsGkAtoms_kind: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20korean_hangul_formalE"]
-            pub static nsGkAtoms_korean_hangul_formal: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19korean_hanja_formalE"]
-            pub static nsGkAtoms_korean_hanja_formal: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21korean_hanja_informalE"]
-            pub static nsGkAtoms_korean_hanja_informal: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5labelE"]
-            pub static nsGkAtoms_label: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6labelsE"]
-            pub static nsGkAtoms_labels: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4langE"]
-            pub static nsGkAtoms_lang: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8languageE"]
-            pub static nsGkAtoms_language: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4lastE"]
-            pub static nsGkAtoms_last: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5layerE"]
-            pub static nsGkAtoms_layer: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13LayerActivityE"]
-            pub static nsGkAtoms_LayerActivity: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6layoutE"]
-            pub static nsGkAtoms_layout: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7leadingE"]
-            pub static nsGkAtoms_leading: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4leafE"]
-            pub static nsGkAtoms_leaf: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4leftE"]
-            pub static nsGkAtoms_left: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10leftmarginE"]
-            pub static nsGkAtoms_leftmargin: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11leftpaddingE"]
-            pub static nsGkAtoms_leftpadding: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6legendE"]
-            pub static nsGkAtoms_legend: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6lengthE"]
-            pub static nsGkAtoms_length: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11letterValueE"]
-            pub static nsGkAtoms_letterValue: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5levelE"]
-            pub static nsGkAtoms_level: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2liE"]
-            pub static nsGkAtoms_li: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4lineE"]
-            pub static nsGkAtoms_line: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4linkE"]
-            pub static nsGkAtoms_link: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7listboxE"]
-            pub static nsGkAtoms_listbox: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11listboxbodyE"]
-            pub static nsGkAtoms_listboxbody: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8listcellE"]
-            pub static nsGkAtoms_listcell: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7listcolE"]
-            pub static nsGkAtoms_listcol: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8listcolsE"]
-            pub static nsGkAtoms_listcols: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8listenerE"]
-            pub static nsGkAtoms_listener: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8listheadE"]
-            pub static nsGkAtoms_listhead: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10listheaderE"]
-            pub static nsGkAtoms_listheader: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7listingE"]
-            pub static nsGkAtoms_listing: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8listitemE"]
-            pub static nsGkAtoms_listitem: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8listrowsE"]
-            pub static nsGkAtoms_listrows: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4loadE"]
-            pub static nsGkAtoms_load: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19triggeringprincipalE"]
-            pub static nsGkAtoms_triggeringprincipal: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9localedirE"]
-            pub static nsGkAtoms_localedir: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9localNameE"]
-            pub static nsGkAtoms_localName: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8longdescE"]
-            pub static nsGkAtoms_longdesc: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4loopE"]
-            pub static nsGkAtoms_loop: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3lowE"]
-            pub static nsGkAtoms_low: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10lowerAlphaE"]
-            pub static nsGkAtoms_lowerAlpha: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10lowerFirstE"]
-            pub static nsGkAtoms_lowerFirst: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10lowerRomanE"]
-            pub static nsGkAtoms_lowerRoman: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6lowestE"]
-            pub static nsGkAtoms_lowest: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6lowsrcE"]
-            pub static nsGkAtoms_lowsrc: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3ltrE"]
-            pub static nsGkAtoms_ltr: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7lwthemeE"]
-            pub static nsGkAtoms_lwtheme: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16lwthemetextcolorE"]
-            pub static nsGkAtoms_lwthemetextcolor: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4mainE"]
-            pub static nsGkAtoms_main: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3mapE"]
-            pub static nsGkAtoms_map: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8manifestE"]
-            pub static nsGkAtoms_manifest: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12marginBottomE"]
-            pub static nsGkAtoms_marginBottom: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10marginLeftE"]
-            pub static nsGkAtoms_marginLeft: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11marginRightE"]
-            pub static nsGkAtoms_marginRight: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9marginTopE"]
-            pub static nsGkAtoms_marginTop: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12marginheightE"]
-            pub static nsGkAtoms_marginheight: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11marginwidthE"]
-            pub static nsGkAtoms_marginwidth: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4markE"]
-            pub static nsGkAtoms_mark: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7marqueeE"]
-            pub static nsGkAtoms_marquee: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5matchE"]
-            pub static nsGkAtoms_match: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3maxE"]
-            pub static nsGkAtoms_max: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9maxheightE"]
-            pub static nsGkAtoms_maxheight: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13maximum_scaleE"]
-            pub static nsGkAtoms_maximum_scale: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9maxlengthE"]
-            pub static nsGkAtoms_maxlength: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6maxposE"]
-            pub static nsGkAtoms_maxpos: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8maxwidthE"]
-            pub static nsGkAtoms_maxwidth: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9mayscriptE"]
-            pub static nsGkAtoms_mayscript: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5mediaE"]
-            pub static nsGkAtoms_media: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9mediaTypeE"]
-            pub static nsGkAtoms_mediaType: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6memberE"]
-            pub static nsGkAtoms_member: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4menuE"]
-            pub static nsGkAtoms_menu: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7menubarE"]
-            pub static nsGkAtoms_menubar: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10menubuttonE"]
-            pub static nsGkAtoms_menubutton: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10menuButtonE"]
-            pub static nsGkAtoms_menuButton: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11menucaptionE"]
-            pub static nsGkAtoms_menucaption: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9menugroupE"]
-            pub static nsGkAtoms_menugroup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8menuitemE"]
-            pub static nsGkAtoms_menuitem: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8menulistE"]
-            pub static nsGkAtoms_menulist: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9menupopupE"]
-            pub static nsGkAtoms_menupopup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13menuseparatorE"]
-            pub static nsGkAtoms_menuseparator: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7messageE"]
-            pub static nsGkAtoms_message: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4metaE"]
-            pub static nsGkAtoms_meta: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8referrerE"]
-            pub static nsGkAtoms_referrer: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14referrerpolicyE"]
-            pub static nsGkAtoms_referrerpolicy: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20headerReferrerPolicyE"]
-            pub static nsGkAtoms_headerReferrerPolicy: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5meterE"]
-            pub static nsGkAtoms_meter: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6methodE"]
-            pub static nsGkAtoms_method: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6middleE"]
-            pub static nsGkAtoms_middle: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3minE"]
-            pub static nsGkAtoms_min: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9minheightE"]
-            pub static nsGkAtoms_minheight: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13minimum_scaleE"]
-            pub static nsGkAtoms_minimum_scale: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9minlengthE"]
-            pub static nsGkAtoms_minlength: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6minposE"]
-            pub static nsGkAtoms_minpos: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9minusSignE"]
-            pub static nsGkAtoms_minusSign: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8minwidthE"]
-            pub static nsGkAtoms_minwidth: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5mixedE"]
-            pub static nsGkAtoms_mixed: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19messagemanagergroupE"]
-            pub static nsGkAtoms_messagemanagergroup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3modE"]
-            pub static nsGkAtoms_mod: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4modeE"]
-            pub static nsGkAtoms_mode: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9modifiersE"]
-            pub static nsGkAtoms_modifiers: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10monochromeE"]
-            pub static nsGkAtoms_monochrome: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9mousedownE"]
-            pub static nsGkAtoms_mousedown: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9mousemoveE"]
-            pub static nsGkAtoms_mousemove: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8mouseoutE"]
-            pub static nsGkAtoms_mouseout: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9mouseoverE"]
-            pub static nsGkAtoms_mouseover: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12mousethroughE"]
-            pub static nsGkAtoms_mousethrough: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7mouseupE"]
-            pub static nsGkAtoms_mouseup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19mozfullscreenchangeE"]
-            pub static nsGkAtoms_mozfullscreenchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18mozfullscreenerrorE"]
-            pub static nsGkAtoms_mozfullscreenerror: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20mozpointerlockchangeE"]
-            pub static nsGkAtoms_mozpointerlockchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19mozpointerlockerrorE"]
-            pub static nsGkAtoms_mozpointerlockerror: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18mozprivatebrowsingE"]
-            pub static nsGkAtoms_mozprivatebrowsing: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10moz_opaqueE"]
-            pub static nsGkAtoms_moz_opaque: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15moz_action_hintE"]
-            pub static nsGkAtoms_moz_action_hint: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18x_moz_errormessageE"]
-            pub static nsGkAtoms_x_moz_errormessage: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8multicolE"]
-            pub static nsGkAtoms_multicol: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8multipleE"]
-            pub static nsGkAtoms_multiple: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4muteE"]
-            pub static nsGkAtoms_mute: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5mutedE"]
-            pub static nsGkAtoms_muted: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4nameE"]
-            pub static nsGkAtoms_name: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10_namespaceE"]
-            pub static nsGkAtoms__namespace: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14namespaceAliasE"]
-            pub static nsGkAtoms_namespaceAlias: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12namespaceUriE"]
-            pub static nsGkAtoms_namespaceUri: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3NaNE"]
-            pub static nsGkAtoms_NaN: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24nativeAnonymousChildListE"]
-            pub static nsGkAtoms_nativeAnonymousChildList: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3navE"]
-            pub static nsGkAtoms_nav: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6negateE"]
-            pub static nsGkAtoms_negate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5neverE"]
-            pub static nsGkAtoms_never: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4_newE"]
-            pub static nsGkAtoms__new: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7newlineE"]
-            pub static nsGkAtoms_newline: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8nextBidiE"]
-            pub static nsGkAtoms_nextBidi: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15nextTabParentIdE"]
-            pub static nsGkAtoms_nextTabParentId: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2noE"]
-            pub static nsGkAtoms_no: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11noautofocusE"]
-            pub static nsGkAtoms_noautofocus: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10noautohideE"]
-            pub static nsGkAtoms_noautohide: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16norolluponanchorE"]
-            pub static nsGkAtoms_norolluponanchor: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4nobrE"]
-            pub static nsGkAtoms_nobr: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4nodeE"]
-            pub static nsGkAtoms_node: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12nodefaultsrcE"]
-            pub static nsGkAtoms_nodefaultsrc: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7nodeSetE"]
-            pub static nsGkAtoms_nodeSet: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7noembedE"]
-            pub static nsGkAtoms_noembed: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8noframesE"]
-            pub static nsGkAtoms_noframes: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6nohrefE"]
-            pub static nsGkAtoms_nohref: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11noisolationE"]
-            pub static nsGkAtoms_noisolation: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8nomoduleE"]
-            pub static nsGkAtoms_nomodule: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5nonceE"]
-            pub static nsGkAtoms_nonce: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4noneE"]
-            pub static nsGkAtoms_none: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8noresizeE"]
-            pub static nsGkAtoms_noresize: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6normalE"]
-            pub static nsGkAtoms_normal: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14normalizeSpaceE"]
-            pub static nsGkAtoms_normalizeSpace: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8noscriptE"]
-            pub static nsGkAtoms_noscript: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7noshadeE"]
-            pub static nsGkAtoms_noshade: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12notificationE"]
-            pub static nsGkAtoms_notification: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10novalidateE"]
-            pub static nsGkAtoms_novalidate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4_notE"]
-            pub static nsGkAtoms__not: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6nowrapE"]
-            pub static nsGkAtoms_nowrap: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6numberE"]
-            pub static nsGkAtoms_number: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4nullE"]
-            pub static nsGkAtoms_null: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6objectE"]
-            pub static nsGkAtoms_object: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10objectTypeE"]
-            pub static nsGkAtoms_objectType: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8observerE"]
-            pub static nsGkAtoms_observer: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8observesE"]
-            pub static nsGkAtoms_observes: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3oddE"]
-            pub static nsGkAtoms_odd: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3OFFE"]
-            pub static nsGkAtoms_OFF: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2olE"]
-            pub static nsGkAtoms_ol: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18omitXmlDeclarationE"]
-            pub static nsGkAtoms_omitXmlDeclaration: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19ona2dpstatuschangedE"]
-            pub static nsGkAtoms_ona2dpstatuschanged: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7onabortE"]
-            pub static nsGkAtoms_onabort: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms22onmozaccesskeynotfoundE"]
-            pub static nsGkAtoms_onmozaccesskeynotfound: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onactivateE"]
-            pub static nsGkAtoms_onactivate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14onadapteraddedE"]
-            pub static nsGkAtoms_onadapteradded: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16onadapterremovedE"]
-            pub static nsGkAtoms_onadapterremoved: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12onafterprintE"]
-            pub static nsGkAtoms_onafterprint: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20onafterscriptexecuteE"]
-            pub static nsGkAtoms_onafterscriptexecute: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onalertingE"]
-            pub static nsGkAtoms_onalerting: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17onanimationcancelE"]
-            pub static nsGkAtoms_onanimationcancel: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14onanimationendE"]
-            pub static nsGkAtoms_onanimationend: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20onanimationiterationE"]
-            pub static nsGkAtoms_onanimationiteration: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16onanimationstartE"]
-            pub static nsGkAtoms_onanimationstart: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24onantennaavailablechangeE"]
-            pub static nsGkAtoms_onantennaavailablechange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12onAppCommandE"]
-            pub static nsGkAtoms_onAppCommand: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14onappinstalledE"]
-            pub static nsGkAtoms_onappinstalled: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18onattributechangedE"]
-            pub static nsGkAtoms_onattributechanged: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18onattributereadreqE"]
-            pub static nsGkAtoms_onattributereadreq: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19onattributewritereqE"]
-            pub static nsGkAtoms_onattributewritereq: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14onaudioprocessE"]
-            pub static nsGkAtoms_onaudioprocess: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onauxclickE"]
-            pub static nsGkAtoms_onauxclick: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12onbeforecopyE"]
-            pub static nsGkAtoms_onbeforecopy: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11onbeforecutE"]
-            pub static nsGkAtoms_onbeforecut: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onbeforepasteE"]
-            pub static nsGkAtoms_onbeforepaste: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15onbeforeevictedE"]
-            pub static nsGkAtoms_onbeforeevicted: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onbeforeprintE"]
-            pub static nsGkAtoms_onbeforeprint: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21onbeforescriptexecuteE"]
-            pub static nsGkAtoms_onbeforescriptexecute: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14onbeforeunloadE"]
-            pub static nsGkAtoms_onbeforeunload: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onblockedE"]
-            pub static nsGkAtoms_onblocked: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6onblurE"]
-            pub static nsGkAtoms_onblur: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11onbroadcastE"]
-            pub static nsGkAtoms_onbroadcast: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6onbusyE"]
-            pub static nsGkAtoms_onbusy: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19onbufferedamountlowE"]
-            pub static nsGkAtoms_onbufferedamountlow: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8oncachedE"]
-            pub static nsGkAtoms_oncached: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14oncallschangedE"]
-            pub static nsGkAtoms_oncallschanged: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8oncancelE"]
-            pub static nsGkAtoms_oncancel: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17oncardstatechangeE"]
-            pub static nsGkAtoms_oncardstatechange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15oncfstatechangeE"]
-            pub static nsGkAtoms_oncfstatechange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8onchangeE"]
-            pub static nsGkAtoms_onchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms23oncharacteristicchangedE"]
-            pub static nsGkAtoms_oncharacteristicchanged: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16onchargingchangeE"]
-            pub static nsGkAtoms_onchargingchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20onchargingtimechangeE"]
-            pub static nsGkAtoms_onchargingtimechange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10oncheckingE"]
-            pub static nsGkAtoms_onchecking: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21onCheckboxStateChangeE"]
-            pub static nsGkAtoms_onCheckboxStateChange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7onclickE"]
-            pub static nsGkAtoms_onclick: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16onclirmodechangeE"]
-            pub static nsGkAtoms_onclirmodechange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7oncloseE"]
-            pub static nsGkAtoms_onclose: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9oncommandE"]
-            pub static nsGkAtoms_oncommand: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15oncommandupdateE"]
-            pub static nsGkAtoms_oncommandupdate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10oncompleteE"]
-            pub static nsGkAtoms_oncomplete: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16oncompositionendE"]
-            pub static nsGkAtoms_oncompositionend: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18oncompositionstartE"]
-            pub static nsGkAtoms_oncompositionstart: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19oncompositionupdateE"]
-            pub static nsGkAtoms_oncompositionupdate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onconnectE"]
-            pub static nsGkAtoms_onconnect: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11onconnectedE"]
-            pub static nsGkAtoms_onconnected: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12onconnectingE"]
-            pub static nsGkAtoms_onconnecting: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21onconnectionavailableE"]
-            pub static nsGkAtoms_onconnectionavailable: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24onconnectionstatechangedE"]
-            pub static nsGkAtoms_onconnectionstatechanged: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13oncontextmenuE"]
-            pub static nsGkAtoms_oncontextmenu: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6oncopyE"]
-            pub static nsGkAtoms_oncopy: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms23oncurrentchannelchangedE"]
-            pub static nsGkAtoms_oncurrentchannelchanged: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms22oncurrentsourcechangedE"]
-            pub static nsGkAtoms_oncurrentsourcechanged: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5oncutE"]
-            pub static nsGkAtoms_oncut: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12ondatachangeE"]
-            pub static nsGkAtoms_ondatachange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11ondataerrorE"]
-            pub static nsGkAtoms_ondataerror: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10ondblclickE"]
-            pub static nsGkAtoms_ondblclick: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9ondeletedE"]
-            pub static nsGkAtoms_ondeleted: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17ondeliverysuccessE"]
-            pub static nsGkAtoms_ondeliverysuccess: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15ondeliveryerrorE"]
-            pub static nsGkAtoms_ondeliveryerror: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13ondevicefoundE"]
-            pub static nsGkAtoms_ondevicefound: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14ondevicepairedE"]
-            pub static nsGkAtoms_ondevicepaired: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16ondeviceunpairedE"]
-            pub static nsGkAtoms_ondeviceunpaired: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9ondialingE"]
-            pub static nsGkAtoms_ondialing: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10ondisabledE"]
-            pub static nsGkAtoms_ondisabled: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms23ondischargingtimechangeE"]
-            pub static nsGkAtoms_ondischargingtimechange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12ondisconnectE"]
-            pub static nsGkAtoms_ondisconnect: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14ondisconnectedE"]
-            pub static nsGkAtoms_ondisconnected: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15ondisconnectingE"]
-            pub static nsGkAtoms_ondisconnecting: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19ondisplaypasskeyreqE"]
-            pub static nsGkAtoms_ondisplaypasskeyreq: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13ondownloadingE"]
-            pub static nsGkAtoms_ondownloading: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onDOMActivateE"]
-            pub static nsGkAtoms_onDOMActivate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17onDOMAttrModifiedE"]
-            pub static nsGkAtoms_onDOMAttrModified: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms26onDOMCharacterDataModifiedE"]
-            pub static nsGkAtoms_onDOMCharacterDataModified: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12onDOMFocusInE"]
-            pub static nsGkAtoms_onDOMFocusIn: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onDOMFocusOutE"]
-            pub static nsGkAtoms_onDOMFocusOut: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16onDOMMouseScrollE"]
-            pub static nsGkAtoms_onDOMMouseScroll: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17onDOMNodeInsertedE"]
-            pub static nsGkAtoms_onDOMNodeInserted: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms29onDOMNodeInsertedIntoDocumentE"]
-            pub static nsGkAtoms_onDOMNodeInsertedIntoDocument: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16onDOMNodeRemovedE"]
-            pub static nsGkAtoms_onDOMNodeRemoved: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms28onDOMNodeRemovedFromDocumentE"]
-            pub static nsGkAtoms_onDOMNodeRemovedFromDocument: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20onDOMSubtreeModifiedE"]
-            pub static nsGkAtoms_onDOMSubtreeModified: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6ondataE"]
-            pub static nsGkAtoms_ondata: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6ondragE"]
-            pub static nsGkAtoms_ondrag: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10ondragdropE"]
-            pub static nsGkAtoms_ondragdrop: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9ondragendE"]
-            pub static nsGkAtoms_ondragend: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11ondragenterE"]
-            pub static nsGkAtoms_ondragenter: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10ondragexitE"]
-            pub static nsGkAtoms_ondragexit: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13ondraggestureE"]
-            pub static nsGkAtoms_ondraggesture: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11ondragleaveE"]
-            pub static nsGkAtoms_ondragleave: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10ondragoverE"]
-            pub static nsGkAtoms_ondragover: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11ondragstartE"]
-            pub static nsGkAtoms_ondragstart: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7ondrainE"]
-            pub static nsGkAtoms_ondrain: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6ondropE"]
-            pub static nsGkAtoms_ondrop: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16oneitbroadcastedE"]
-            pub static nsGkAtoms_oneitbroadcasted: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onenabledE"]
-            pub static nsGkAtoms_onenabled: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17onenterpincodereqE"]
-            pub static nsGkAtoms_onenterpincodereq: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms23onemergencycbmodechangeE"]
-            pub static nsGkAtoms_onemergencycbmodechange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7onerrorE"]
-            pub static nsGkAtoms_onerror: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onevictedE"]
-            pub static nsGkAtoms_onevicted: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8onfailedE"]
-            pub static nsGkAtoms_onfailed: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7onfetchE"]
-            pub static nsGkAtoms_onfetch: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8onfinishE"]
-            pub static nsGkAtoms_onfinish: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7onfocusE"]
-            pub static nsGkAtoms_onfocus: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onfocusinE"]
-            pub static nsGkAtoms_onfocusin: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onfocusoutE"]
-            pub static nsGkAtoms_onfocusout: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17onfrequencychangeE"]
-            pub static nsGkAtoms_onfrequencychange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18onfullscreenchangeE"]
-            pub static nsGkAtoms_onfullscreenchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17onfullscreenerrorE"]
-            pub static nsGkAtoms_onfullscreenerror: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21onspeakerforcedchangeE"]
-            pub static nsGkAtoms_onspeakerforcedchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5ongetE"]
-            pub static nsGkAtoms_onget: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13ongroupchangeE"]
-            pub static nsGkAtoms_ongroupchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12onhashchangeE"]
-            pub static nsGkAtoms_onhashchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18onheadphoneschangeE"]
-            pub static nsGkAtoms_onheadphoneschange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6onheldE"]
-            pub static nsGkAtoms_onheld: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18onhfpstatuschangedE"]
-            pub static nsGkAtoms_onhfpstatuschanged: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18onhidstatuschangedE"]
-            pub static nsGkAtoms_onhidstatuschanged: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onholdingE"]
-            pub static nsGkAtoms_onholding: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11oniccchangeE"]
-            pub static nsGkAtoms_oniccchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13oniccdetectedE"]
-            pub static nsGkAtoms_oniccdetected: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15oniccinfochangeE"]
-            pub static nsGkAtoms_oniccinfochange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15oniccundetectedE"]
-            pub static nsGkAtoms_oniccundetected: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onincomingE"]
-            pub static nsGkAtoms_onincoming: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7oninputE"]
-            pub static nsGkAtoms_oninput: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9oninstallE"]
-            pub static nsGkAtoms_oninstall: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9oninvalidE"]
-            pub static nsGkAtoms_oninvalid: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onkeydownE"]
-            pub static nsGkAtoms_onkeydown: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onkeypressE"]
-            pub static nsGkAtoms_onkeypress: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7onkeyupE"]
-            pub static nsGkAtoms_onkeyup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16onlanguagechangeE"]
-            pub static nsGkAtoms_onlanguagechange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onlevelchangeE"]
-            pub static nsGkAtoms_onlevelchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6onLoadE"]
-            pub static nsGkAtoms_onLoad: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6onloadE"]
-            pub static nsGkAtoms_onload: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onloadingE"]
-            pub static nsGkAtoms_onloading: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onloadingdoneE"]
-            pub static nsGkAtoms_onloadingdone: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14onloadingerrorE"]
-            pub static nsGkAtoms_onloadingerror: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onpopstateE"]
-            pub static nsGkAtoms_onpopstate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4onlyE"]
-            pub static nsGkAtoms_only: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onmessageE"]
-            pub static nsGkAtoms_onmessage: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14onmessageerrorE"]
-            pub static nsGkAtoms_onmessageerror: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onmidimessageE"]
-            pub static nsGkAtoms_onmidimessage: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11onmousedownE"]
-            pub static nsGkAtoms_onmousedown: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12onmouseenterE"]
-            pub static nsGkAtoms_onmouseenter: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12onmouseleaveE"]
-            pub static nsGkAtoms_onmouseleave: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14onmouselongtapE"]
-            pub static nsGkAtoms_onmouselongtap: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11onmousemoveE"]
-            pub static nsGkAtoms_onmousemove: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onmouseoutE"]
-            pub static nsGkAtoms_onmouseout: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11onmouseoverE"]
-            pub static nsGkAtoms_onmouseover: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17onMozMouseHittestE"]
-            pub static nsGkAtoms_onMozMouseHittest: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onmouseupE"]
-            pub static nsGkAtoms_onmouseup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15onMozAfterPaintE"]
-            pub static nsGkAtoms_onMozAfterPaint: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21onmozfullscreenchangeE"]
-            pub static nsGkAtoms_onmozfullscreenchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20onmozfullscreenerrorE"]
-            pub static nsGkAtoms_onmozfullscreenerror: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20onmozkeydownonpluginE"]
-            pub static nsGkAtoms_onmozkeydownonplugin: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18onmozkeyuponpluginE"]
-            pub static nsGkAtoms_onmozkeyuponplugin: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms22onmozpointerlockchangeE"]
-            pub static nsGkAtoms_onmozpointerlockchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21onmozpointerlockerrorE"]
-            pub static nsGkAtoms_onmozpointerlockerror: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21onMozMousePixelScrollE"]
-            pub static nsGkAtoms_onMozMousePixelScroll: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24onMozScrolledAreaChangedE"]
-            pub static nsGkAtoms_onMozScrolledAreaChanged: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21onmapfolderlistingreqE"]
-            pub static nsGkAtoms_onmapfolderlistingreq: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms23onmapmessageslistingreqE"]
-            pub static nsGkAtoms_onmapmessageslistingreq: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18onmapgetmessagereqE"]
-            pub static nsGkAtoms_onmapgetmessagereq: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24onmapsetmessagestatusreqE"]
-            pub static nsGkAtoms_onmapsetmessagestatusreq: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19onmapsendmessagereqE"]
-            pub static nsGkAtoms_onmapsendmessagereq: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21onmapmessageupdatereqE"]
-            pub static nsGkAtoms_onmapmessageupdatereq: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6onmuteE"]
-            pub static nsGkAtoms_onmute: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onnewrdsgroupE"]
-            pub static nsGkAtoms_onnewrdsgroup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19onnotificationclickE"]
-            pub static nsGkAtoms_onnotificationclick: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19onnotificationcloseE"]
-            pub static nsGkAtoms_onnotificationclose: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onnoupdateE"]
-            pub static nsGkAtoms_onnoupdate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17onobexpasswordreqE"]
-            pub static nsGkAtoms_onobexpasswordreq: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onobsoleteE"]
-            pub static nsGkAtoms_onobsolete: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8ononlineE"]
-            pub static nsGkAtoms_ononline: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onofflineE"]
-            pub static nsGkAtoms_onoffline: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6onopenE"]
-            pub static nsGkAtoms_onopen: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19onorientationchangeE"]
-            pub static nsGkAtoms_onorientationchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17onotastatuschangeE"]
-            pub static nsGkAtoms_onotastatuschange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onoverflowE"]
-            pub static nsGkAtoms_onoverflow: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17onoverflowchangedE"]
-            pub static nsGkAtoms_onoverflowchanged: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onpagehideE"]
-            pub static nsGkAtoms_onpagehide: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onpageshowE"]
-            pub static nsGkAtoms_onpageshow: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7onpaintE"]
-            pub static nsGkAtoms_onpaint: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16onpairingabortedE"]
-            pub static nsGkAtoms_onpairingaborted: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24onpairingconfirmationreqE"]
-            pub static nsGkAtoms_onpairingconfirmationreq: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19onpairingconsentreqE"]
-            pub static nsGkAtoms_onpairingconsentreq: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7onpasteE"]
-            pub static nsGkAtoms_onpaste: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15onpendingchangeE"]
-            pub static nsGkAtoms_onpendingchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onpichangeE"]
-            pub static nsGkAtoms_onpichange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19onpointerlockchangeE"]
-            pub static nsGkAtoms_onpointerlockchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18onpointerlockerrorE"]
-            pub static nsGkAtoms_onpointerlockerror: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onpopuphiddenE"]
-            pub static nsGkAtoms_onpopuphidden: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onpopuphidingE"]
-            pub static nsGkAtoms_onpopuphiding: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17onpopuppositionedE"]
-            pub static nsGkAtoms_onpopuppositioned: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14onpopupshowingE"]
-            pub static nsGkAtoms_onpopupshowing: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12onpopupshownE"]
-            pub static nsGkAtoms_onpopupshown: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18onpullphonebookreqE"]
-            pub static nsGkAtoms_onpullphonebookreq: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19onpullvcardentryreqE"]
-            pub static nsGkAtoms_onpullvcardentryreq: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21onpullvcardlistingreqE"]
-            pub static nsGkAtoms_onpullvcardlistingreq: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6onpushE"]
-            pub static nsGkAtoms_onpush: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24onpushsubscriptionchangeE"]
-            pub static nsGkAtoms_onpushsubscriptionchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onpschangeE"]
-            pub static nsGkAtoms_onpschange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11onptychangeE"]
-            pub static nsGkAtoms_onptychange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18onradiostatechangeE"]
-            pub static nsGkAtoms_onradiostatechange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18onRadioStateChangeE"]
-            pub static nsGkAtoms_onRadioStateChange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onrdsdisabledE"]
-            pub static nsGkAtoms_onrdsdisabled: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12onrdsenabledE"]
-            pub static nsGkAtoms_onrdsenabled: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11onreaderrorE"]
-            pub static nsGkAtoms_onreaderror: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onreadsuccessE"]
-            pub static nsGkAtoms_onreadsuccess: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7onreadyE"]
-            pub static nsGkAtoms_onready: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18onreadystatechangeE"]
-            pub static nsGkAtoms_onreadystatechange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onreceivedE"]
-            pub static nsGkAtoms_onreceived: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12onremoteheldE"]
-            pub static nsGkAtoms_onremoteheld: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15onremoteresumedE"]
-            pub static nsGkAtoms_onremoteresumed: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17onrequestprogressE"]
-            pub static nsGkAtoms_onrequestprogress: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms26onresourcetimingbufferfullE"]
-            pub static nsGkAtoms_onresourcetimingbufferfull: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18onresponseprogressE"]
-            pub static nsGkAtoms_onresponseprogress: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12onretrievingE"]
-            pub static nsGkAtoms_onretrieving: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onRequestE"]
-            pub static nsGkAtoms_onRequest: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24onrequestmediaplaystatusE"]
-            pub static nsGkAtoms_onrequestmediaplaystatus: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7onresetE"]
-            pub static nsGkAtoms_onreset: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onresumingE"]
-            pub static nsGkAtoms_onresuming: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8onresizeE"]
-            pub static nsGkAtoms_onresize: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onrtchangeE"]
-            pub static nsGkAtoms_onrtchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms22onscanningstatechangedE"]
-            pub static nsGkAtoms_onscanningstatechanged: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18onscostatuschangedE"]
-            pub static nsGkAtoms_onscostatuschanged: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8onscrollE"]
-            pub static nsGkAtoms_onscroll: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8onselectE"]
-            pub static nsGkAtoms_onselect: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17onselectionchangeE"]
-            pub static nsGkAtoms_onselectionchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onselectstartE"]
-            pub static nsGkAtoms_onselectstart: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onsendingE"]
-            pub static nsGkAtoms_onsending: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6onsentE"]
-            pub static nsGkAtoms_onsent: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5onsetE"]
-            pub static nsGkAtoms_onset: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms23onshippingaddresschangeE"]
-            pub static nsGkAtoms_onshippingaddresschange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms22onshippingoptionchangeE"]
-            pub static nsGkAtoms_onshippingoptionchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6onshowE"]
-            pub static nsGkAtoms_onshow: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onstatechangeE"]
-            pub static nsGkAtoms_onstatechange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15onstatuschangedE"]
-            pub static nsGkAtoms_onstatuschanged: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12onstkcommandE"]
-            pub static nsGkAtoms_onstkcommand: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15onstksessionendE"]
-            pub static nsGkAtoms_onstksessionend: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onstorageE"]
-            pub static nsGkAtoms_onstorage: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20onstorageareachangedE"]
-            pub static nsGkAtoms_onstorageareachanged: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8onsubmitE"]
-            pub static nsGkAtoms_onsubmit: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onsuccessE"]
-            pub static nsGkAtoms_onsuccess: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12ontypechangeE"]
-            pub static nsGkAtoms_ontypechange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11onterminateE"]
-            pub static nsGkAtoms_onterminate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6ontextE"]
-            pub static nsGkAtoms_ontext: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8ontoggleE"]
-            pub static nsGkAtoms_ontoggle: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12ontouchstartE"]
-            pub static nsGkAtoms_ontouchstart: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10ontouchendE"]
-            pub static nsGkAtoms_ontouchend: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11ontouchmoveE"]
-            pub static nsGkAtoms_ontouchmove: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13ontouchcancelE"]
-            pub static nsGkAtoms_ontouchcancel: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18ontransitioncancelE"]
-            pub static nsGkAtoms_ontransitioncancel: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15ontransitionendE"]
-            pub static nsGkAtoms_ontransitionend: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15ontransitionrunE"]
-            pub static nsGkAtoms_ontransitionrun: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17ontransitionstartE"]
-            pub static nsGkAtoms_ontransitionstart: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11onunderflowE"]
-            pub static nsGkAtoms_onunderflow: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8onunloadE"]
-            pub static nsGkAtoms_onunload: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8onunmuteE"]
-            pub static nsGkAtoms_onunmute: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onupdatefoundE"]
-            pub static nsGkAtoms_onupdatefound: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onupdatereadyE"]
-            pub static nsGkAtoms_onupdateready: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15onupgradeneededE"]
-            pub static nsGkAtoms_onupgradeneeded: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14onussdreceivedE"]
-            pub static nsGkAtoms_onussdreceived: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15onversionchangeE"]
-            pub static nsGkAtoms_onversionchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18onvisibilitychangeE"]
-            pub static nsGkAtoms_onvisibilitychange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onvoicechangeE"]
-            pub static nsGkAtoms_onvoicechange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15onvoiceschangedE"]
-            pub static nsGkAtoms_onvoiceschanged: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19onvrdisplayactivateE"]
-            pub static nsGkAtoms_onvrdisplayactivate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18onvrdisplayconnectE"]
-            pub static nsGkAtoms_onvrdisplayconnect: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21onvrdisplaydeactivateE"]
-            pub static nsGkAtoms_onvrdisplaydeactivate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21onvrdisplaydisconnectE"]
-            pub static nsGkAtoms_onvrdisplaydisconnect: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24onvrdisplaypresentchangeE"]
-            pub static nsGkAtoms_onvrdisplaypresentchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20onwebkitAnimationEndE"]
-            pub static nsGkAtoms_onwebkitAnimationEnd: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms26onwebkitAnimationIterationE"]
-            pub static nsGkAtoms_onwebkitAnimationIteration: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms22onwebkitAnimationStartE"]
-            pub static nsGkAtoms_onwebkitAnimationStart: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21onwebkitTransitionEndE"]
-            pub static nsGkAtoms_onwebkitTransitionEnd: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20onwebkitanimationendE"]
-            pub static nsGkAtoms_onwebkitanimationend: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms26onwebkitanimationiterationE"]
-            pub static nsGkAtoms_onwebkitanimationiteration: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms22onwebkitanimationstartE"]
-            pub static nsGkAtoms_onwebkitanimationstart: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21onwebkittransitionendE"]
-            pub static nsGkAtoms_onwebkittransitionend: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11onwebsocketE"]
-            pub static nsGkAtoms_onwebsocket: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7onwheelE"]
-            pub static nsGkAtoms_onwheel: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4openE"]
-            pub static nsGkAtoms_open: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8optgroupE"]
-            pub static nsGkAtoms_optgroup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7optimumE"]
-            pub static nsGkAtoms_optimum: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6optionE"]
-            pub static nsGkAtoms_option: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3_orE"]
-            pub static nsGkAtoms__or: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5orderE"]
-            pub static nsGkAtoms_order: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7ordinalE"]
-            pub static nsGkAtoms_ordinal: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6orientE"]
-            pub static nsGkAtoms_orient: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11orientationE"]
-            pub static nsGkAtoms_orientation: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9otherwiseE"]
-            pub static nsGkAtoms_otherwise: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6outputE"]
-            pub static nsGkAtoms_output: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8overflowE"]
-            pub static nsGkAtoms_overflow: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15overflowchangedE"]
-            pub static nsGkAtoms_overflowchanged: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7overlayE"]
-            pub static nsGkAtoms_overlay: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7overlapE"]
-            pub static nsGkAtoms_overlap: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms1pE"]
-            pub static nsGkAtoms_p: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4packE"]
-            pub static nsGkAtoms_pack: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4pageE"]
-            pub static nsGkAtoms_page: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13pageincrementE"]
-            pub static nsGkAtoms_pageincrement: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5pagexE"]
-            pub static nsGkAtoms_pagex: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5pageyE"]
-            pub static nsGkAtoms_pagey: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11paint_orderE"]
-            pub static nsGkAtoms_paint_order: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11palettenameE"]
-            pub static nsGkAtoms_palettename: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5panelE"]
-            pub static nsGkAtoms_panel: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5paramE"]
-            pub static nsGkAtoms_param: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9parameterE"]
-            pub static nsGkAtoms_parameter: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6parentE"]
-            pub static nsGkAtoms_parent: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13parentfocusedE"]
-            pub static nsGkAtoms_parentfocused: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9parsetypeE"]
-            pub static nsGkAtoms_parsetype: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8passwordE"]
-            pub static nsGkAtoms_password: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7patternE"]
-            pub static nsGkAtoms_pattern: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16patternSeparatorE"]
-            pub static nsGkAtoms_patternSeparator: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8perMilleE"]
-            pub static nsGkAtoms_perMille: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7percentE"]
-            pub static nsGkAtoms_percent: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7persistE"]
-            pub static nsGkAtoms_persist: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5phaseE"]
-            pub static nsGkAtoms_phase: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7pictureE"]
-            pub static nsGkAtoms_picture: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4pingE"]
-            pub static nsGkAtoms_ping: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6pinnedE"]
-            pub static nsGkAtoms_pinned: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11placeholderE"]
-            pub static nsGkAtoms_placeholder: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9plaintextE"]
-            pub static nsGkAtoms_plaintext: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12playbackrateE"]
-            pub static nsGkAtoms_playbackrate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9pointSizeE"]
-            pub static nsGkAtoms_pointSize: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17pointerlockchangeE"]
-            pub static nsGkAtoms_pointerlockchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16pointerlockerrorE"]
-            pub static nsGkAtoms_pointerlockerror: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4polyE"]
-            pub static nsGkAtoms_poly: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7polygonE"]
-            pub static nsGkAtoms_polygon: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5popupE"]
-            pub static nsGkAtoms_popup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10popupalignE"]
-            pub static nsGkAtoms_popupalign: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11popupanchorE"]
-            pub static nsGkAtoms_popupanchor: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10popupgroupE"]
-            pub static nsGkAtoms_popupgroup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11popuphiddenE"]
-            pub static nsGkAtoms_popuphidden: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11popuphidingE"]
-            pub static nsGkAtoms_popuphiding: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8popupsetE"]
-            pub static nsGkAtoms_popupset: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12popupshowingE"]
-            pub static nsGkAtoms_popupshowing: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10popupshownE"]
-            pub static nsGkAtoms_popupshown: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20popupsinherittooltipE"]
-            pub static nsGkAtoms_popupsinherittooltip: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8positionE"]
-            pub static nsGkAtoms_position: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6posterE"]
-            pub static nsGkAtoms_poster: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3preE"]
-            pub static nsGkAtoms_pre: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9precedingE"]
-            pub static nsGkAtoms_preceding: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16precedingSiblingE"]
-            pub static nsGkAtoms_precedingSibling: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9predicateE"]
-            pub static nsGkAtoms_predicate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6prefixE"]
-            pub static nsGkAtoms_prefix: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7preloadE"]
-            pub static nsGkAtoms_preload: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15mozpresentationE"]
-            pub static nsGkAtoms_mozpresentation: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8preserveE"]
-            pub static nsGkAtoms_preserve: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13preserveSpaceE"]
-            pub static nsGkAtoms_preserveSpace: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14preventdefaultE"]
-            pub static nsGkAtoms_preventdefault: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7primaryE"]
-            pub static nsGkAtoms_primary: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5printE"]
-            pub static nsGkAtoms_print: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8priorityE"]
-            pub static nsGkAtoms_priority: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21processingInstructionE"]
-            pub static nsGkAtoms_processingInstruction: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7profileE"]
-            pub static nsGkAtoms_profile: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8progressE"]
-            pub static nsGkAtoms_progress: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13progressmeterE"]
-            pub static nsGkAtoms_progressmeter: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14progressNormalE"]
-            pub static nsGkAtoms_progressNormal: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20progressUndeterminedE"]
-            pub static nsGkAtoms_progressUndetermined: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10projectionE"]
-            pub static nsGkAtoms_projection: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6promptE"]
-            pub static nsGkAtoms_prompt: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9propagateE"]
-            pub static nsGkAtoms_propagate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10propertiesE"]
-            pub static nsGkAtoms_properties: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8propertyE"]
-            pub static nsGkAtoms_property: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7pubdateE"]
-            pub static nsGkAtoms_pubdate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms1qE"]
-            pub static nsGkAtoms_q: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5queryE"]
-            pub static nsGkAtoms_query: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8querysetE"]
-            pub static nsGkAtoms_queryset: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9querytypeE"]
-            pub static nsGkAtoms_querytype: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5radioE"]
-            pub static nsGkAtoms_radio: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10radiogroupE"]
-            pub static nsGkAtoms_radiogroup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5rangeE"]
-            pub static nsGkAtoms_range: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8readonlyE"]
-            pub static nsGkAtoms_readonly: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4rectE"]
-            pub static nsGkAtoms_rect: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9rectangleE"]
-            pub static nsGkAtoms_rectangle: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7refreshE"]
-            pub static nsGkAtoms_refresh: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3relE"]
-            pub static nsGkAtoms_rel: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12onreloadpageE"]
-            pub static nsGkAtoms_onreloadpage: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3remE"]
-            pub static nsGkAtoms_rem: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6remoteE"]
-            pub static nsGkAtoms_remote: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13removeelementE"]
-            pub static nsGkAtoms_removeelement: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21renderingobserverlistE"]
-            pub static nsGkAtoms_renderingobserverlist: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6repeatE"]
-            pub static nsGkAtoms_repeat: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7replaceE"]
-            pub static nsGkAtoms_replace: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16requestcontextidE"]
-            pub static nsGkAtoms_requestcontextid: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8requiredE"]
-            pub static nsGkAtoms_required: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8reservedE"]
-            pub static nsGkAtoms_reserved: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5resetE"]
-            pub static nsGkAtoms_reset: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11resizeafterE"]
-            pub static nsGkAtoms_resizeafter: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12resizebeforeE"]
-            pub static nsGkAtoms_resizebefore: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7resizerE"]
-            pub static nsGkAtoms_resizer: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10resolutionE"]
-            pub static nsGkAtoms_resolution: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9resourcesE"]
-            pub static nsGkAtoms_resources: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6resultE"]
-            pub static nsGkAtoms_result: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12resultPrefixE"]
-            pub static nsGkAtoms_resultPrefix: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21retargetdocumentfocusE"]
-            pub static nsGkAtoms_retargetdocumentfocus: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3revE"]
-            pub static nsGkAtoms_rev: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7reverseE"]
-            pub static nsGkAtoms_reverse: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8reversedE"]
-            pub static nsGkAtoms_reversed: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11richlistboxE"]
-            pub static nsGkAtoms_richlistbox: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12richlistitemE"]
-            pub static nsGkAtoms_richlistitem: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5rightE"]
-            pub static nsGkAtoms_right: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11rightmarginE"]
-            pub static nsGkAtoms_rightmargin: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12rightpaddingE"]
-            pub static nsGkAtoms_rightpadding: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4roleE"]
-            pub static nsGkAtoms_role: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18rolluponmousewheelE"]
-            pub static nsGkAtoms_rolluponmousewheel: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5roundE"]
-            pub static nsGkAtoms_round: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3rowE"]
-            pub static nsGkAtoms_row: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4rowsE"]
-            pub static nsGkAtoms_rows: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7rowspanE"]
-            pub static nsGkAtoms_rowspan: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2rbE"]
-            pub static nsGkAtoms_rb: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2rpE"]
-            pub static nsGkAtoms_rp: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2rtE"]
-            pub static nsGkAtoms_rt: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3rtcE"]
-            pub static nsGkAtoms_rtc: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3rtlE"]
-            pub static nsGkAtoms_rtl: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4rubyE"]
-            pub static nsGkAtoms_ruby: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8rubyBaseE"]
-            pub static nsGkAtoms_rubyBase: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17rubyBaseContainerE"]
-            pub static nsGkAtoms_rubyBaseContainer: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8rubyTextE"]
-            pub static nsGkAtoms_rubyText: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17rubyTextContainerE"]
-            pub static nsGkAtoms_rubyTextContainer: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4ruleE"]
-            pub static nsGkAtoms_rule: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5rulesE"]
-            pub static nsGkAtoms_rules: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms1sE"]
-            pub static nsGkAtoms_s: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4sampE"]
-            pub static nsGkAtoms_samp: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7sandboxE"]
-            pub static nsGkAtoms_sandbox: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6sbattrE"]
-            pub static nsGkAtoms_sbattr: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5scaleE"]
-            pub static nsGkAtoms_scale: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4scanE"]
-            pub static nsGkAtoms_scan: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6schemeE"]
-            pub static nsGkAtoms_scheme: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5scopeE"]
-            pub static nsGkAtoms_scope: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6scopedE"]
-            pub static nsGkAtoms_scoped: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6screenE"]
-            pub static nsGkAtoms_screen: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7screenXE"]
-            pub static nsGkAtoms_screenX: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7screenYE"]
-            pub static nsGkAtoms_screenY: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6scriptE"]
-            pub static nsGkAtoms_script: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms33scriptEnabledBeforePrintOrPreviewE"]
-            pub static nsGkAtoms_scriptEnabledBeforePrintOrPreview: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9scrollbarE"]
-            pub static nsGkAtoms_scrollbar: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15scrollbarbuttonE"]
-            pub static nsGkAtoms_scrollbarbutton: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19scrollbarDownBottomE"]
-            pub static nsGkAtoms_scrollbarDownBottom: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16scrollbarDownTopE"]
-            pub static nsGkAtoms_scrollbarDownTop: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17scrollbarUpBottomE"]
-            pub static nsGkAtoms_scrollbarUpBottom: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14scrollbarUpTopE"]
-            pub static nsGkAtoms_scrollbarUpTop: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9scrollboxE"]
-            pub static nsGkAtoms_scrollbox: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12scrollcornerE"]
-            pub static nsGkAtoms_scrollcorner: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9scrollingE"]
-            pub static nsGkAtoms_scrolling: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14scrollPositionE"]
-            pub static nsGkAtoms_scrollPosition: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7sectionE"]
-            pub static nsGkAtoms_section: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6selectE"]
-            pub static nsGkAtoms_select: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10selectableE"]
-            pub static nsGkAtoms_selectable: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8selectedE"]
-            pub static nsGkAtoms_selected: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13selectedIndexE"]
-            pub static nsGkAtoms_selectedIndex: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13selectedindexE"]
-            pub static nsGkAtoms_selectedindex: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4selfE"]
-            pub static nsGkAtoms_self: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7seltypeE"]
-            pub static nsGkAtoms_seltype: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9setcookieE"]
-            pub static nsGkAtoms_setcookie: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6setterE"]
-            pub static nsGkAtoms_setter: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5shapeE"]
-            pub static nsGkAtoms_shape: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4showE"]
-            pub static nsGkAtoms_show: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9showcaretE"]
-            pub static nsGkAtoms_showcaret: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11showresizerE"]
-            pub static nsGkAtoms_showresizer: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6simpleE"]
-            pub static nsGkAtoms_simple: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19simp_chinese_formalE"]
-            pub static nsGkAtoms_simp_chinese_formal: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21simp_chinese_informalE"]
-            pub static nsGkAtoms_simp_chinese_informal: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6singleE"]
-            pub static nsGkAtoms_single: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4sizeE"]
-            pub static nsGkAtoms_size: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5sizesE"]
-            pub static nsGkAtoms_sizes: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8sizemodeE"]
-            pub static nsGkAtoms_sizemode: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11sizetopopupE"]
-            pub static nsGkAtoms_sizetopopup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6sliderE"]
-            pub static nsGkAtoms_slider: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5smallE"]
-            pub static nsGkAtoms_small: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6smoothE"]
-            pub static nsGkAtoms_smooth: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4snapE"]
-            pub static nsGkAtoms_snap: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4sortE"]
-            pub static nsGkAtoms_sort: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10sortActiveE"]
-            pub static nsGkAtoms_sortActive: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13sortDirectionE"]
-            pub static nsGkAtoms_sortDirection: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6sortedE"]
-            pub static nsGkAtoms_sorted: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9sorthintsE"]
-            pub static nsGkAtoms_sorthints: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10sortLockedE"]
-            pub static nsGkAtoms_sortLocked: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6sourceE"]
-            pub static nsGkAtoms_source: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5spaceE"]
-            pub static nsGkAtoms_space: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6spacerE"]
-            pub static nsGkAtoms_spacer: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4spanE"]
-            pub static nsGkAtoms_span: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10spellcheckE"]
-            pub static nsGkAtoms_spellcheck: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7spinnerE"]
-            pub static nsGkAtoms_spinner: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5splitE"]
-            pub static nsGkAtoms_split: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8splitterE"]
-            pub static nsGkAtoms_splitter: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6springE"]
-            pub static nsGkAtoms_spring: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6squareE"]
-            pub static nsGkAtoms_square: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3srcE"]
-            pub static nsGkAtoms_src: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6srcdocE"]
-            pub static nsGkAtoms_srcdoc: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7srclangE"]
-            pub static nsGkAtoms_srclang: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6srcsetE"]
-            pub static nsGkAtoms_srcset: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5stackE"]
-            pub static nsGkAtoms_stack: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10standaloneE"]
-            pub static nsGkAtoms_standalone: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7standbyE"]
-            pub static nsGkAtoms_standby: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5startE"]
-            pub static nsGkAtoms_start: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11start_afterE"]
-            pub static nsGkAtoms_start_after: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12start_beforeE"]
-            pub static nsGkAtoms_start_before: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10startsWithE"]
-            pub static nsGkAtoms_startsWith: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5stateE"]
-            pub static nsGkAtoms_state: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15statedatasourceE"]
-            pub static nsGkAtoms_statedatasource: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10staticHintE"]
-            pub static nsGkAtoms_staticHint: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9statusbarE"]
-            pub static nsGkAtoms_statusbar: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10statustextE"]
-            pub static nsGkAtoms_statustext: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4stepE"]
-            pub static nsGkAtoms_step: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4stopE"]
-            pub static nsGkAtoms_stop: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7stretchE"]
-            pub static nsGkAtoms_stretch: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6strikeE"]
-            pub static nsGkAtoms_strike: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6stringE"]
-            pub static nsGkAtoms_string: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12stringLengthE"]
-            pub static nsGkAtoms_stringLength: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10stripSpaceE"]
-            pub static nsGkAtoms_stripSpace: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6strongE"]
-            pub static nsGkAtoms_strong: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5styleE"]
-            pub static nsGkAtoms_style: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10stylesheetE"]
-            pub static nsGkAtoms_stylesheet: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16stylesheetPrefixE"]
-            pub static nsGkAtoms_stylesheetPrefix: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7subjectE"]
-            pub static nsGkAtoms_subject: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6submitE"]
-            pub static nsGkAtoms_submit: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8substateE"]
-            pub static nsGkAtoms_substate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9substringE"]
-            pub static nsGkAtoms_substring: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14substringAfterE"]
-            pub static nsGkAtoms_substringAfter: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15substringBeforeE"]
-            pub static nsGkAtoms_substringBefore: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3subE"]
-            pub static nsGkAtoms_sub: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3sumE"]
-            pub static nsGkAtoms_sum: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3supE"]
-            pub static nsGkAtoms_sup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7summaryE"]
-            pub static nsGkAtoms_summary: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14systemPropertyE"]
-            pub static nsGkAtoms_systemProperty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3tabE"]
-            pub static nsGkAtoms_tab: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6tabboxE"]
-            pub static nsGkAtoms_tabbox: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8tabindexE"]
-            pub static nsGkAtoms_tabindex: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5tableE"]
-            pub static nsGkAtoms_table: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8tabpanelE"]
-            pub static nsGkAtoms_tabpanel: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9tabpanelsE"]
-            pub static nsGkAtoms_tabpanels: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3tagE"]
-            pub static nsGkAtoms_tag: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6targetE"]
-            pub static nsGkAtoms_target: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7targetsE"]
-            pub static nsGkAtoms_targets: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5tbodyE"]
-            pub static nsGkAtoms_tbody: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2tdE"]
-            pub static nsGkAtoms_td: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9_templateE"]
-            pub static nsGkAtoms__template: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15text_decorationE"]
-            pub static nsGkAtoms_text_decoration: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9terminateE"]
-            pub static nsGkAtoms_terminate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4termE"]
-            pub static nsGkAtoms_term: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4testE"]
-            pub static nsGkAtoms_test: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4textE"]
-            pub static nsGkAtoms_text: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9textAlignE"]
-            pub static nsGkAtoms_textAlign: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8textareaE"]
-            pub static nsGkAtoms_textarea: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7textboxE"]
-            pub static nsGkAtoms_textbox: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8textnodeE"]
-            pub static nsGkAtoms_textnode: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms25textNodeDirectionalityMapE"]
-            pub static nsGkAtoms_textNodeDirectionalityMap: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5tfootE"]
-            pub static nsGkAtoms_tfoot: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2thE"]
-            pub static nsGkAtoms_th: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5theadE"]
-            pub static nsGkAtoms_thead: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5thumbE"]
-            pub static nsGkAtoms_thumb: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4timeE"]
-            pub static nsGkAtoms_time: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5titleE"]
-            pub static nsGkAtoms_title: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8titlebarE"]
-            pub static nsGkAtoms_titlebar: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8titletipE"]
-            pub static nsGkAtoms_titletip: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7toggledE"]
-            pub static nsGkAtoms_toggled: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5tokenE"]
-            pub static nsGkAtoms_token: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8tokenizeE"]
-            pub static nsGkAtoms_tokenize: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7toolbarE"]
-            pub static nsGkAtoms_toolbar: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13toolbarbuttonE"]
-            pub static nsGkAtoms_toolbarbutton: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11toolbaritemE"]
-            pub static nsGkAtoms_toolbaritem: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7toolboxE"]
-            pub static nsGkAtoms_toolbox: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7tooltipE"]
-            pub static nsGkAtoms_tooltip: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11tooltiptextE"]
-            pub static nsGkAtoms_tooltiptext: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3topE"]
-            pub static nsGkAtoms_top: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7topleftE"]
-            pub static nsGkAtoms_topleft: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9topmarginE"]
-            pub static nsGkAtoms_topmargin: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10toppaddingE"]
-            pub static nsGkAtoms_toppadding: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8toprightE"]
-            pub static nsGkAtoms_topright: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2trE"]
-            pub static nsGkAtoms_tr: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5trackE"]
-            pub static nsGkAtoms_track: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19trad_chinese_formalE"]
-            pub static nsGkAtoms_trad_chinese_formal: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21trad_chinese_informalE"]
-            pub static nsGkAtoms_trad_chinese_informal: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8trailingE"]
-            pub static nsGkAtoms_trailing: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9transformE"]
-            pub static nsGkAtoms_transform: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12transform_3dE"]
-            pub static nsGkAtoms_transform_3d: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12transformiixE"]
-            pub static nsGkAtoms_transformiix: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9translateE"]
-            pub static nsGkAtoms_translate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11transparentE"]
-            pub static nsGkAtoms_transparent: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4treeE"]
-            pub static nsGkAtoms_tree: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8treecellE"]
-            pub static nsGkAtoms_treecell: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12treechildrenE"]
-            pub static nsGkAtoms_treechildren: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7treecolE"]
-            pub static nsGkAtoms_treecol: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13treecolpickerE"]
-            pub static nsGkAtoms_treecolpicker: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8treecolsE"]
-            pub static nsGkAtoms_treecols: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8treeitemE"]
-            pub static nsGkAtoms_treeitem: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7treerowE"]
-            pub static nsGkAtoms_treerow: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13treeseparatorE"]
-            pub static nsGkAtoms_treeseparator: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6tripleE"]
-            pub static nsGkAtoms_triple: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5_trueE"]
-            pub static nsGkAtoms__true: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2ttE"]
-            pub static nsGkAtoms_tt: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3ttyE"]
-            pub static nsGkAtoms_tty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2tvE"]
-            pub static nsGkAtoms_tv: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4typeE"]
-            pub static nsGkAtoms_type: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13typemustmatchE"]
-            pub static nsGkAtoms_typemustmatch: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms1uE"]
-            pub static nsGkAtoms_u: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2ulE"]
-            pub static nsGkAtoms_ul: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9underflowE"]
-            pub static nsGkAtoms_underflow: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12undeterminedE"]
-            pub static nsGkAtoms_undetermined: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6unloadE"]
-            pub static nsGkAtoms_unload: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6unmuteE"]
-            pub static nsGkAtoms_unmute: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17unparsedEntityUriE"]
-            pub static nsGkAtoms_unparsedEntityUri: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10upperAlphaE"]
-            pub static nsGkAtoms_upperAlpha: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10upperFirstE"]
-            pub static nsGkAtoms_upperFirst: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10upperRomanE"]
-            pub static nsGkAtoms_upperRoman: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3uriE"]
-            pub static nsGkAtoms_uri: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3useE"]
-            pub static nsGkAtoms_use: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16useAttributeSetsE"]
-            pub static nsGkAtoms_useAttributeSets: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6usemapE"]
-            pub static nsGkAtoms_usemap: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13user_scalableE"]
-            pub static nsGkAtoms_user_scalable: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9userInputE"]
-            pub static nsGkAtoms_userInput: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8validateE"]
-            pub static nsGkAtoms_validate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6valignE"]
-            pub static nsGkAtoms_valign: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5valueE"]
-            pub static nsGkAtoms_value: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6valuesE"]
-            pub static nsGkAtoms_values: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7valueOfE"]
-            pub static nsGkAtoms_valueOf: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9valuetypeE"]
-            pub static nsGkAtoms_valuetype: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3varE"]
-            pub static nsGkAtoms_var: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8variableE"]
-            pub static nsGkAtoms_variable: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4vboxE"]
-            pub static nsGkAtoms_vbox: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10vcard_nameE"]
-            pub static nsGkAtoms_vcard_name: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6vendorE"]
-            pub static nsGkAtoms_vendor: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9vendorUrlE"]
-            pub static nsGkAtoms_vendorUrl: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7versionE"]
-            pub static nsGkAtoms_version: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4vertE"]
-            pub static nsGkAtoms_vert: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8verticalE"]
-            pub static nsGkAtoms_vertical: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5audioE"]
-            pub static nsGkAtoms_audio: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5videoE"]
-            pub static nsGkAtoms_video: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13videocontrolsE"]
-            pub static nsGkAtoms_videocontrols: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8viewportE"]
-            pub static nsGkAtoms_viewport: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15viewport_heightE"]
-            pub static nsGkAtoms_viewport_height: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms22viewport_initial_scaleE"]
-            pub static nsGkAtoms_viewport_initial_scale: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms22viewport_maximum_scaleE"]
-            pub static nsGkAtoms_viewport_maximum_scale: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms22viewport_minimum_scaleE"]
-            pub static nsGkAtoms_viewport_minimum_scale: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms22viewport_user_scalableE"]
-            pub static nsGkAtoms_viewport_user_scalable: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14viewport_widthE"]
-            pub static nsGkAtoms_viewport_width: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10visibilityE"]
-            pub static nsGkAtoms_visibility: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16visuallyselectedE"]
-            pub static nsGkAtoms_visuallyselected: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5vlinkE"]
-            pub static nsGkAtoms_vlink: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6vspaceE"]
-            pub static nsGkAtoms_vspace: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3wbrE"]
-            pub static nsGkAtoms_wbr: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15webkitdirectoryE"]
-            pub static nsGkAtoms_webkitdirectory: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4whenE"]
-            pub static nsGkAtoms_when: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5whereE"]
-            pub static nsGkAtoms_where: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6widgetE"]
-            pub static nsGkAtoms_widget: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5widthE"]
-            pub static nsGkAtoms_width: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10willChangeE"]
-            pub static nsGkAtoms_willChange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6windowE"]
-            pub static nsGkAtoms_window: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18headerWindowTargetE"]
-            pub static nsGkAtoms_headerWindowTarget: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10windowtypeE"]
-            pub static nsGkAtoms_windowtype: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9withParamE"]
-            pub static nsGkAtoms_withParam: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6wizardE"]
-            pub static nsGkAtoms_wizard: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4wrapE"]
-            pub static nsGkAtoms_wrap: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24headerDNSPrefetchControlE"]
-            pub static nsGkAtoms_headerDNSPrefetchControl: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9headerCSPE"]
-            pub static nsGkAtoms_headerCSP: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19headerCSPReportOnlyE"]
-            pub static nsGkAtoms_headerCSPReportOnly: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9headerXFOE"]
-            pub static nsGkAtoms_headerXFO: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9x_westernE"]
-            pub static nsGkAtoms_x_western: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3xmlE"]
-            pub static nsGkAtoms_xml: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14xml_stylesheetE"]
-            pub static nsGkAtoms_xml_stylesheet: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5xmlnsE"]
-            pub static nsGkAtoms_xmlns: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3xmpE"]
-            pub static nsGkAtoms_xmp: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20xulcontentsgeneratedE"]
-            pub static nsGkAtoms_xulcontentsgenerated: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3yesE"]
-            pub static nsGkAtoms_yes: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7z_indexE"]
-            pub static nsGkAtoms_z_index: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9zeroDigitE"]
-            pub static nsGkAtoms_zeroDigit: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10percentageE"]
-            pub static nsGkAtoms_percentage: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms1AE"]
-            pub static nsGkAtoms_A: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18alignment_baselineE"]
-            pub static nsGkAtoms_alignment_baseline: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9amplitudeE"]
-            pub static nsGkAtoms_amplitude: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7animateE"]
-            pub static nsGkAtoms_animate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12animateColorE"]
-            pub static nsGkAtoms_animateColor: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13animateMotionE"]
-            pub static nsGkAtoms_animateMotion: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16animateTransformE"]
-            pub static nsGkAtoms_animateTransform: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10arithmeticE"]
-            pub static nsGkAtoms_arithmetic: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4atopE"]
-            pub static nsGkAtoms_atop: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7azimuthE"]
-            pub static nsGkAtoms_azimuth: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms1BE"]
-            pub static nsGkAtoms_B: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15backgroundColorE"]
-            pub static nsGkAtoms_backgroundColor: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16background_imageE"]
-            pub static nsGkAtoms_background_image: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13baseFrequencyE"]
-            pub static nsGkAtoms_baseFrequency: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14baseline_shiftE"]
-            pub static nsGkAtoms_baseline_shift: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4biasE"]
-            pub static nsGkAtoms_bias: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12caption_sideE"]
-            pub static nsGkAtoms_caption_side: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9clip_pathE"]
-            pub static nsGkAtoms_clip_path: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9clip_ruleE"]
-            pub static nsGkAtoms_clip_rule: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8clipPathE"]
-            pub static nsGkAtoms_clipPath: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13clipPathUnitsE"]
-            pub static nsGkAtoms_clipPathUnits: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2cmE"]
-            pub static nsGkAtoms_cm: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9colorBurnE"]
-            pub static nsGkAtoms_colorBurn: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10colorDodgeE"]
-            pub static nsGkAtoms_colorDodge: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18colorInterpolationE"]
-            pub static nsGkAtoms_colorInterpolation: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms25colorInterpolationFiltersE"]
-            pub static nsGkAtoms_colorInterpolationFilters: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11colorpickerE"]
-            pub static nsGkAtoms_colorpicker: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12colorProfileE"]
-            pub static nsGkAtoms_colorProfile: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6cursorE"]
-            pub static nsGkAtoms_cursor: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2cxE"]
-            pub static nsGkAtoms_cx: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2cyE"]
-            pub static nsGkAtoms_cy: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms1dE"]
-            pub static nsGkAtoms_d: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6darkenE"]
-            pub static nsGkAtoms_darken: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4defsE"]
-            pub static nsGkAtoms_defs: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3degE"]
-            pub static nsGkAtoms_deg: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4descE"]
-            pub static nsGkAtoms_desc: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15diffuseConstantE"]
-            pub static nsGkAtoms_diffuseConstant: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6dilateE"]
-            pub static nsGkAtoms_dilate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9directionE"]
-            pub static nsGkAtoms_direction: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7disableE"]
-            pub static nsGkAtoms_disable: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4discE"]
-            pub static nsGkAtoms_disc: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8discreteE"]
-            pub static nsGkAtoms_discrete: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7divisorE"]
-            pub static nsGkAtoms_divisor: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17dominant_baselineE"]
-            pub static nsGkAtoms_dominant_baseline: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9duplicateE"]
-            pub static nsGkAtoms_duplicate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2dxE"]
-            pub static nsGkAtoms_dx: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2dyE"]
-            pub static nsGkAtoms_dy: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8edgeModeE"]
-            pub static nsGkAtoms_edgeMode: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7ellipseE"]
-            pub static nsGkAtoms_ellipse: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9elevationE"]
-            pub static nsGkAtoms_elevation: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5erodeE"]
-            pub static nsGkAtoms_erode: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2exE"]
-            pub static nsGkAtoms_ex: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5exactE"]
-            pub static nsGkAtoms_exact: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9exclusionE"]
-            pub static nsGkAtoms_exclusion: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8exponentE"]
-            pub static nsGkAtoms_exponent: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7feBlendE"]
-            pub static nsGkAtoms_feBlend: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13feColorMatrixE"]
-            pub static nsGkAtoms_feColorMatrix: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19feComponentTransferE"]
-            pub static nsGkAtoms_feComponentTransfer: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11feCompositeE"]
-            pub static nsGkAtoms_feComposite: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16feConvolveMatrixE"]
-            pub static nsGkAtoms_feConvolveMatrix: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17feDiffuseLightingE"]
-            pub static nsGkAtoms_feDiffuseLighting: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17feDisplacementMapE"]
-            pub static nsGkAtoms_feDisplacementMap: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14feDistantLightE"]
-            pub static nsGkAtoms_feDistantLight: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12feDropShadowE"]
-            pub static nsGkAtoms_feDropShadow: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7feFloodE"]
-            pub static nsGkAtoms_feFlood: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7feFuncAE"]
-            pub static nsGkAtoms_feFuncA: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7feFuncBE"]
-            pub static nsGkAtoms_feFuncB: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7feFuncGE"]
-            pub static nsGkAtoms_feFuncG: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7feFuncRE"]
-            pub static nsGkAtoms_feFuncR: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14feGaussianBlurE"]
-            pub static nsGkAtoms_feGaussianBlur: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7feImageE"]
-            pub static nsGkAtoms_feImage: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7feMergeE"]
-            pub static nsGkAtoms_feMerge: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11feMergeNodeE"]
-            pub static nsGkAtoms_feMergeNode: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12feMorphologyE"]
-            pub static nsGkAtoms_feMorphology: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8feOffsetE"]
-            pub static nsGkAtoms_feOffset: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12fePointLightE"]
-            pub static nsGkAtoms_fePointLight: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18feSpecularLightingE"]
-            pub static nsGkAtoms_feSpecularLighting: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11feSpotLightE"]
-            pub static nsGkAtoms_feSpotLight: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6feTileE"]
-            pub static nsGkAtoms_feTile: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12feTurbulenceE"]
-            pub static nsGkAtoms_feTurbulence: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4fillE"]
-            pub static nsGkAtoms_fill: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12fill_opacityE"]
-            pub static nsGkAtoms_fill_opacity: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9fill_ruleE"]
-            pub static nsGkAtoms_fill_rule: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6filterE"]
-            pub static nsGkAtoms_filter: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11filterUnitsE"]
-            pub static nsGkAtoms_filterUnits: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6_floatE"]
-            pub static nsGkAtoms__float: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11flood_colorE"]
-            pub static nsGkAtoms_flood_color: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13flood_opacityE"]
-            pub static nsGkAtoms_flood_opacity: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9font_faceE"]
-            pub static nsGkAtoms_font_face: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16font_face_formatE"]
-            pub static nsGkAtoms_font_face_format: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14font_face_nameE"]
-            pub static nsGkAtoms_font_face_name: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13font_face_srcE"]
-            pub static nsGkAtoms_font_face_src: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13font_face_uriE"]
-            pub static nsGkAtoms_font_face_uri: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11font_familyE"]
-            pub static nsGkAtoms_font_family: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9font_sizeE"]
-            pub static nsGkAtoms_font_size: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16font_size_adjustE"]
-            pub static nsGkAtoms_font_size_adjust: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12font_stretchE"]
-            pub static nsGkAtoms_font_stretch: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10font_styleE"]
-            pub static nsGkAtoms_font_style: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12font_variantE"]
-            pub static nsGkAtoms_font_variant: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13foreignObjectE"]
-            pub static nsGkAtoms_foreignObject: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12fractalNoiseE"]
-            pub static nsGkAtoms_fractalNoise: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2frE"]
-            pub static nsGkAtoms_fr: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2fxE"]
-            pub static nsGkAtoms_fx: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2fyE"]
-            pub static nsGkAtoms_fy: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms1GE"]
-            pub static nsGkAtoms_G: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms1gE"]
-            pub static nsGkAtoms_g: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5gammaE"]
-            pub static nsGkAtoms_gamma: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8generic_E"]
-            pub static nsGkAtoms_generic_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8glyphRefE"]
-            pub static nsGkAtoms_glyphRef: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4gradE"]
-            pub static nsGkAtoms_grad: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17gradientTransformE"]
-            pub static nsGkAtoms_gradientTransform: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13gradientUnitsE"]
-            pub static nsGkAtoms_gradientUnits: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9hardLightE"]
-            pub static nsGkAtoms_hardLight: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3hueE"]
-            pub static nsGkAtoms_hue: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9hueRotateE"]
-            pub static nsGkAtoms_hueRotate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8identityE"]
-            pub static nsGkAtoms_identity: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15image_renderingE"]
-            pub static nsGkAtoms_image_rendering: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2inE"]
-            pub static nsGkAtoms_in: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3in2E"]
-            pub static nsGkAtoms_in2: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9interceptE"]
-            pub static nsGkAtoms_intercept: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2k1E"]
-            pub static nsGkAtoms_k1: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2k2E"]
-            pub static nsGkAtoms_k2: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2k3E"]
-            pub static nsGkAtoms_k3: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2k4E"]
-            pub static nsGkAtoms_k4: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12kernelMatrixE"]
-            pub static nsGkAtoms_kernelMatrix: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16kernelUnitLengthE"]
-            pub static nsGkAtoms_kernelUnitLength: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12lengthAdjustE"]
-            pub static nsGkAtoms_lengthAdjust: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14letter_spacingE"]
-            pub static nsGkAtoms_letter_spacing: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7lightenE"]
-            pub static nsGkAtoms_lighten: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14lighting_colorE"]
-            pub static nsGkAtoms_lighting_color: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17limitingConeAngleE"]
-            pub static nsGkAtoms_limitingConeAngle: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6linearE"]
-            pub static nsGkAtoms_linear: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14linearGradientE"]
-            pub static nsGkAtoms_linearGradient: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9linearRGBE"]
-            pub static nsGkAtoms_linearRGB: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15list_style_typeE"]
-            pub static nsGkAtoms_list_style_type: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16luminanceToAlphaE"]
-            pub static nsGkAtoms_luminanceToAlpha: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10luminosityE"]
-            pub static nsGkAtoms_luminosity: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7magnifyE"]
-            pub static nsGkAtoms_magnify: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6markerE"]
-            pub static nsGkAtoms_marker: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10marker_endE"]
-            pub static nsGkAtoms_marker_end: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10marker_midE"]
-            pub static nsGkAtoms_marker_mid: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12marker_startE"]
-            pub static nsGkAtoms_marker_start: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12markerHeightE"]
-            pub static nsGkAtoms_markerHeight: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11markerUnitsE"]
-            pub static nsGkAtoms_markerUnits: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11markerWidthE"]
-            pub static nsGkAtoms_markerWidth: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4maskE"]
-            pub static nsGkAtoms_mask: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16maskContentUnitsE"]
-            pub static nsGkAtoms_maskContentUnits: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9mask_typeE"]
-            pub static nsGkAtoms_mask_type: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9maskUnitsE"]
-            pub static nsGkAtoms_maskUnits: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6matrixE"]
-            pub static nsGkAtoms_matrix: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8metadataE"]
-            pub static nsGkAtoms_metadata: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12missingGlyphE"]
-            pub static nsGkAtoms_missingGlyph: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2mmE"]
-            pub static nsGkAtoms_mm: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5mpathE"]
-            pub static nsGkAtoms_mpath: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8noStitchE"]
-            pub static nsGkAtoms_noStitch: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10numOctavesE"]
-            pub static nsGkAtoms_numOctaves: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8multiplyE"]
-            pub static nsGkAtoms_multiply: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17objectBoundingBoxE"]
-            pub static nsGkAtoms_objectBoundingBox: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6offsetE"]
-            pub static nsGkAtoms_offset: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onSVGLoadE"]
-            pub static nsGkAtoms_onSVGLoad: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11onSVGResizeE"]
-            pub static nsGkAtoms_onSVGResize: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11onSVGScrollE"]
-            pub static nsGkAtoms_onSVGScroll: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11onSVGUnloadE"]
-            pub static nsGkAtoms_onSVGUnload: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onSVGZoomE"]
-            pub static nsGkAtoms_onSVGZoom: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6onzoomE"]
-            pub static nsGkAtoms_onzoom: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7opacityE"]
-            pub static nsGkAtoms_opacity: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9_operatorE"]
-            pub static nsGkAtoms__operator: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3outE"]
-            pub static nsGkAtoms_out: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4overE"]
-            pub static nsGkAtoms_over: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms27overridePreserveAspectRatioE"]
-            pub static nsGkAtoms_overridePreserveAspectRatio: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3padE"]
-            pub static nsGkAtoms_pad: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4pathE"]
-            pub static nsGkAtoms_path: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10pathLengthE"]
-            pub static nsGkAtoms_pathLength: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19patternContentUnitsE"]
-            pub static nsGkAtoms_patternContentUnits: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16patternTransformE"]
-            pub static nsGkAtoms_patternTransform: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12patternUnitsE"]
-            pub static nsGkAtoms_patternUnits: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2pcE"]
-            pub static nsGkAtoms_pc: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14pointer_eventsE"]
-            pub static nsGkAtoms_pointer_events: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6pointsE"]
-            pub static nsGkAtoms_points: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9pointsAtXE"]
-            pub static nsGkAtoms_pointsAtX: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9pointsAtYE"]
-            pub static nsGkAtoms_pointsAtY: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9pointsAtZE"]
-            pub static nsGkAtoms_pointsAtZ: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8polylineE"]
-            pub static nsGkAtoms_polyline: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13preserveAlphaE"]
-            pub static nsGkAtoms_preserveAlpha: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19preserveAspectRatioE"]
-            pub static nsGkAtoms_preserveAspectRatio: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14primitiveUnitsE"]
-            pub static nsGkAtoms_primitiveUnits: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2ptE"]
-            pub static nsGkAtoms_pt: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2pxE"]
-            pub static nsGkAtoms_px: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms1RE"]
-            pub static nsGkAtoms_R: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms1rE"]
-            pub static nsGkAtoms_r: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3radE"]
-            pub static nsGkAtoms_rad: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14radialGradientE"]
-            pub static nsGkAtoms_radialGradient: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6radiusE"]
-            pub static nsGkAtoms_radius: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7reflectE"]
-            pub static nsGkAtoms_reflect: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4refXE"]
-            pub static nsGkAtoms_refX: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4refYE"]
-            pub static nsGkAtoms_refY: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18requiredExtensionsE"]
-            pub static nsGkAtoms_requiredExtensions: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16requiredFeaturesE"]
-            pub static nsGkAtoms_requiredFeatures: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6rotateE"]
-            pub static nsGkAtoms_rotate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2rxE"]
-            pub static nsGkAtoms_rx: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2ryE"]
-            pub static nsGkAtoms_ry: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8saturateE"]
-            pub static nsGkAtoms_saturate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10saturationE"]
-            pub static nsGkAtoms_saturation: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3setE"]
-            pub static nsGkAtoms_set: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4seedE"]
-            pub static nsGkAtoms_seed: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15shape_renderingE"]
-            pub static nsGkAtoms_shape_rendering: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16simpleScopeChainE"]
-            pub static nsGkAtoms_simpleScopeChain: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5skewXE"]
-            pub static nsGkAtoms_skewX: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5skewYE"]
-            pub static nsGkAtoms_skewY: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5slopeE"]
-            pub static nsGkAtoms_slope: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4slotE"]
-            pub static nsGkAtoms_slot: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9softLightE"]
-            pub static nsGkAtoms_softLight: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7spacingE"]
-            pub static nsGkAtoms_spacing: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16spacingAndGlyphsE"]
-            pub static nsGkAtoms_spacingAndGlyphs: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16specularConstantE"]
-            pub static nsGkAtoms_specularConstant: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16specularExponentE"]
-            pub static nsGkAtoms_specularExponent: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12spreadMethodE"]
-            pub static nsGkAtoms_spreadMethod: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4sRGBE"]
-            pub static nsGkAtoms_sRGB: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11startOffsetE"]
-            pub static nsGkAtoms_startOffset: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12stdDeviationE"]
-            pub static nsGkAtoms_stdDeviation: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6stitchE"]
-            pub static nsGkAtoms_stitch: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11stitchTilesE"]
-            pub static nsGkAtoms_stitchTiles: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10stop_colorE"]
-            pub static nsGkAtoms_stop_color: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12stop_opacityE"]
-            pub static nsGkAtoms_stop_opacity: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6strokeE"]
-            pub static nsGkAtoms_stroke: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16stroke_dasharrayE"]
-            pub static nsGkAtoms_stroke_dasharray: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17stroke_dashoffsetE"]
-            pub static nsGkAtoms_stroke_dashoffset: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14stroke_linecapE"]
-            pub static nsGkAtoms_stroke_linecap: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15stroke_linejoinE"]
-            pub static nsGkAtoms_stroke_linejoin: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17stroke_miterlimitE"]
-            pub static nsGkAtoms_stroke_miterlimit: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14stroke_opacityE"]
-            pub static nsGkAtoms_stroke_opacity: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12stroke_widthE"]
-            pub static nsGkAtoms_stroke_width: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11strokeWidthE"]
-            pub static nsGkAtoms_strokeWidth: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12surfaceScaleE"]
-            pub static nsGkAtoms_surfaceScale: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3svgE"]
-            pub static nsGkAtoms_svg: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15svgContextPaintE"]
-            pub static nsGkAtoms_svgContextPaint: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9svgSwitchE"]
-            pub static nsGkAtoms_svgSwitch: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6symbolE"]
-            pub static nsGkAtoms_symbol: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14systemLanguageE"]
-            pub static nsGkAtoms_systemLanguage: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11tableValuesE"]
-            pub static nsGkAtoms_tableValues: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7targetXE"]
-            pub static nsGkAtoms_targetX: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7targetYE"]
-            pub static nsGkAtoms_targetY: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11text_anchorE"]
-            pub static nsGkAtoms_text_anchor: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14text_renderingE"]
-            pub static nsGkAtoms_text_rendering: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10textLengthE"]
-            pub static nsGkAtoms_textLength: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8textPathE"]
-            pub static nsGkAtoms_textPath: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4trefE"]
-            pub static nsGkAtoms_tref: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5tspanE"]
-            pub static nsGkAtoms_tspan: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10turbulenceE"]
-            pub static nsGkAtoms_turbulence: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12unicode_bidiE"]
-            pub static nsGkAtoms_unicode_bidi: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14userSpaceOnUseE"]
-            pub static nsGkAtoms_userSpaceOnUse: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4viewE"]
-            pub static nsGkAtoms_view: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7viewBoxE"]
-            pub static nsGkAtoms_viewBox: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10viewTargetE"]
-            pub static nsGkAtoms_viewTarget: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11white_spaceE"]
-            pub static nsGkAtoms_white_space: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12word_spacingE"]
-            pub static nsGkAtoms_word_spacing: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12writing_modeE"]
-            pub static nsGkAtoms_writing_mode: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms1xE"]
-            pub static nsGkAtoms_x: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2x1E"]
-            pub static nsGkAtoms_x1: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2x2E"]
-            pub static nsGkAtoms_x2: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16xChannelSelectorE"]
-            pub static nsGkAtoms_xChannelSelector: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4xor_E"]
-            pub static nsGkAtoms_xor_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms1yE"]
-            pub static nsGkAtoms_y: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2y1E"]
-            pub static nsGkAtoms_y1: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2y2E"]
-            pub static nsGkAtoms_y2: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16yChannelSelectorE"]
-            pub static nsGkAtoms_yChannelSelector: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms1zE"]
-            pub static nsGkAtoms_z: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10zoomAndPanE"]
-            pub static nsGkAtoms_zoomAndPan: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13vector_effectE"]
-            pub static nsGkAtoms_vector_effect: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14vertical_alignE"]
-            pub static nsGkAtoms_vertical_align: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10accumulateE"]
-            pub static nsGkAtoms_accumulate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8additiveE"]
-            pub static nsGkAtoms_additive: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13attributeNameE"]
-            pub static nsGkAtoms_attributeName: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13attributeTypeE"]
-            pub static nsGkAtoms_attributeType: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12auto_reverseE"]
-            pub static nsGkAtoms_auto_reverse: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5beginE"]
-            pub static nsGkAtoms_begin: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10beginEventE"]
-            pub static nsGkAtoms_beginEvent: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2byE"]
-            pub static nsGkAtoms_by: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8calcModeE"]
-            pub static nsGkAtoms_calcMode: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3cssE"]
-            pub static nsGkAtoms_css: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3durE"]
-            pub static nsGkAtoms_dur: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9keyPointsE"]
-            pub static nsGkAtoms_keyPoints: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10keySplinesE"]
-            pub static nsGkAtoms_keySplines: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8keyTimesE"]
-            pub static nsGkAtoms_keyTimes: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms25mozAnimateMotionDummyAttrE"]
-            pub static nsGkAtoms_mozAnimateMotionDummyAttr: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7onbeginE"]
-            pub static nsGkAtoms_onbegin: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12onbeginEventE"]
-            pub static nsGkAtoms_onbeginEvent: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5onendE"]
-            pub static nsGkAtoms_onend: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onendEventE"]
-            pub static nsGkAtoms_onendEvent: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8onrepeatE"]
-            pub static nsGkAtoms_onrepeat: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onrepeatEventE"]
-            pub static nsGkAtoms_onrepeatEvent: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11repeatCountE"]
-            pub static nsGkAtoms_repeatCount: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9repeatDurE"]
-            pub static nsGkAtoms_repeatDur: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11repeatEventE"]
-            pub static nsGkAtoms_repeatEvent: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7restartE"]
-            pub static nsGkAtoms_restart: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2toE"]
-            pub static nsGkAtoms_to: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3XMLE"]
-            pub static nsGkAtoms_XML: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4abs_E"]
-            pub static nsGkAtoms_abs_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7accent_E"]
-            pub static nsGkAtoms_accent_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12accentunder_E"]
-            pub static nsGkAtoms_accentunder_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11actiontype_E"]
-            pub static nsGkAtoms_actiontype_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15alignmentscope_E"]
-            pub static nsGkAtoms_alignmentscope_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7altimg_E"]
-            pub static nsGkAtoms_altimg_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14altimg_height_E"]
-            pub static nsGkAtoms_altimg_height_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14altimg_valign_E"]
-            pub static nsGkAtoms_altimg_valign_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13altimg_width_E"]
-            pub static nsGkAtoms_altimg_width_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11annotation_E"]
-            pub static nsGkAtoms_annotation_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15annotation_xml_E"]
-            pub static nsGkAtoms_annotation_xml_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6apply_E"]
-            pub static nsGkAtoms_apply_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7approx_E"]
-            pub static nsGkAtoms_approx_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7arccos_E"]
-            pub static nsGkAtoms_arccos_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8arccosh_E"]
-            pub static nsGkAtoms_arccosh_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7arccot_E"]
-            pub static nsGkAtoms_arccot_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8arccoth_E"]
-            pub static nsGkAtoms_arccoth_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7arccsc_E"]
-            pub static nsGkAtoms_arccsc_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8arccsch_E"]
-            pub static nsGkAtoms_arccsch_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7arcsec_E"]
-            pub static nsGkAtoms_arcsec_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8arcsech_E"]
-            pub static nsGkAtoms_arcsech_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7arcsin_E"]
-            pub static nsGkAtoms_arcsin_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8arcsinh_E"]
-            pub static nsGkAtoms_arcsinh_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7arctan_E"]
-            pub static nsGkAtoms_arctan_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8arctanh_E"]
-            pub static nsGkAtoms_arctanh_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4arg_E"]
-            pub static nsGkAtoms_arg_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9bevelled_E"]
-            pub static nsGkAtoms_bevelled_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5bind_E"]
-            pub static nsGkAtoms_bind_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5bvar_E"]
-            pub static nsGkAtoms_bvar_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5card_E"]
-            pub static nsGkAtoms_card_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17cartesianproduct_E"]
-            pub static nsGkAtoms_cartesianproduct_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7cbytes_E"]
-            pub static nsGkAtoms_cbytes_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3cd_E"]
-            pub static nsGkAtoms_cd_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8cdgroup_E"]
-            pub static nsGkAtoms_cdgroup_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7cerror_E"]
-            pub static nsGkAtoms_cerror_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10charalign_E"]
-            pub static nsGkAtoms_charalign_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3ci_E"]
-            pub static nsGkAtoms_ci_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8closure_E"]
-            pub static nsGkAtoms_closure_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3cn_E"]
-            pub static nsGkAtoms_cn_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9codomain_E"]
-            pub static nsGkAtoms_codomain_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12columnalign_E"]
-            pub static nsGkAtoms_columnalign_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16columnalignment_E"]
-            pub static nsGkAtoms_columnalignment_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12columnlines_E"]
-            pub static nsGkAtoms_columnlines_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14columnspacing_E"]
-            pub static nsGkAtoms_columnspacing_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11columnspan_E"]
-            pub static nsGkAtoms_columnspan_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12columnwidth_E"]
-            pub static nsGkAtoms_columnwidth_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10complexes_E"]
-            pub static nsGkAtoms_complexes_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8compose_E"]
-            pub static nsGkAtoms_compose_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10condition_E"]
-            pub static nsGkAtoms_condition_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10conjugate_E"]
-            pub static nsGkAtoms_conjugate_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4cos_E"]
-            pub static nsGkAtoms_cos_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5cosh_E"]
-            pub static nsGkAtoms_cosh_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4cot_E"]
-            pub static nsGkAtoms_cot_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5coth_E"]
-            pub static nsGkAtoms_coth_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9crossout_E"]
-            pub static nsGkAtoms_crossout_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4csc_E"]
-            pub static nsGkAtoms_csc_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5csch_E"]
-            pub static nsGkAtoms_csch_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3cs_E"]
-            pub static nsGkAtoms_cs_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8csymbol_E"]
-            pub static nsGkAtoms_csymbol_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5curl_E"]
-            pub static nsGkAtoms_curl_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13decimalpoint_E"]
-            pub static nsGkAtoms_decimalpoint_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14definitionURL_E"]
-            pub static nsGkAtoms_definitionURL_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7degree_E"]
-            pub static nsGkAtoms_degree_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11denomalign_E"]
-            pub static nsGkAtoms_denomalign_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6depth_E"]
-            pub static nsGkAtoms_depth_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12determinant_E"]
-            pub static nsGkAtoms_determinant_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5diff_E"]
-            pub static nsGkAtoms_diff_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13displaystyle_E"]
-            pub static nsGkAtoms_displaystyle_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11divergence_E"]
-            pub static nsGkAtoms_divergence_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7divide_E"]
-            pub static nsGkAtoms_divide_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7domain_E"]
-            pub static nsGkAtoms_domain_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20domainofapplication_E"]
-            pub static nsGkAtoms_domainofapplication_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5edge_E"]
-            pub static nsGkAtoms_edge_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2elE"]
-            pub static nsGkAtoms_el: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9emptyset_E"]
-            pub static nsGkAtoms_emptyset_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3eq_E"]
-            pub static nsGkAtoms_eq_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13equalcolumns_E"]
-            pub static nsGkAtoms_equalcolumns_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10equalrows_E"]
-            pub static nsGkAtoms_equalrows_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11equivalent_E"]
-            pub static nsGkAtoms_equivalent_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11eulergamma_E"]
-            pub static nsGkAtoms_eulergamma_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7exists_E"]
-            pub static nsGkAtoms_exists_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4exp_E"]
-            pub static nsGkAtoms_exp_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13exponentiale_E"]
-            pub static nsGkAtoms_exponentiale_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10factorial_E"]
-            pub static nsGkAtoms_factorial_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9factorof_E"]
-            pub static nsGkAtoms_factorof_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6fence_E"]
-            pub static nsGkAtoms_fence_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3fn_E"]
-            pub static nsGkAtoms_fn_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11fontfamily_E"]
-            pub static nsGkAtoms_fontfamily_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9fontsize_E"]
-            pub static nsGkAtoms_fontsize_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10fontstyle_E"]
-            pub static nsGkAtoms_fontstyle_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11fontweight_E"]
-            pub static nsGkAtoms_fontweight_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7forall_E"]
-            pub static nsGkAtoms_forall_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13framespacing_E"]
-            pub static nsGkAtoms_framespacing_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4gcd_E"]
-            pub static nsGkAtoms_gcd_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4geq_E"]
-            pub static nsGkAtoms_geq_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11groupalign_E"]
-            pub static nsGkAtoms_groupalign_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3gt_E"]
-            pub static nsGkAtoms_gt_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6ident_E"]
-            pub static nsGkAtoms_ident_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11imaginaryi_E"]
-            pub static nsGkAtoms_imaginaryi_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10imaginary_E"]
-            pub static nsGkAtoms_imaginary_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8implies_E"]
-            pub static nsGkAtoms_implies_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17indentalignfirst_E"]
-            pub static nsGkAtoms_indentalignfirst_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12indentalign_E"]
-            pub static nsGkAtoms_indentalign_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16indentalignlast_E"]
-            pub static nsGkAtoms_indentalignlast_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17indentshiftfirst_E"]
-            pub static nsGkAtoms_indentshiftfirst_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12indentshift_E"]
-            pub static nsGkAtoms_indentshift_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13indenttarget_E"]
-            pub static nsGkAtoms_indenttarget_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9integers_E"]
-            pub static nsGkAtoms_integers_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10intersect_E"]
-            pub static nsGkAtoms_intersect_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9interval_E"]
-            pub static nsGkAtoms_interval_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4int_E"]
-            pub static nsGkAtoms_int_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8inverse_E"]
-            pub static nsGkAtoms_inverse_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7lambda_E"]
-            pub static nsGkAtoms_lambda_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10laplacian_E"]
-            pub static nsGkAtoms_laplacian_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8largeop_E"]
-            pub static nsGkAtoms_largeop_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4lcm_E"]
-            pub static nsGkAtoms_lcm_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4leq_E"]
-            pub static nsGkAtoms_leq_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6limit_E"]
-            pub static nsGkAtoms_limit_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10linebreak_E"]
-            pub static nsGkAtoms_linebreak_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18linebreakmultchar_E"]
-            pub static nsGkAtoms_linebreakmultchar_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15linebreakstyle_E"]
-            pub static nsGkAtoms_linebreakstyle_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14linethickness_E"]
-            pub static nsGkAtoms_linethickness_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5list_E"]
-            pub static nsGkAtoms_list_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3ln_E"]
-            pub static nsGkAtoms_ln_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9location_E"]
-            pub static nsGkAtoms_location_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8logbase_E"]
-            pub static nsGkAtoms_logbase_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4log_E"]
-            pub static nsGkAtoms_log_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13longdivstyle_E"]
-            pub static nsGkAtoms_longdivstyle_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9lowlimit_E"]
-            pub static nsGkAtoms_lowlimit_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7lquote_E"]
-            pub static nsGkAtoms_lquote_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7lspace_E"]
-            pub static nsGkAtoms_lspace_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3lt_E"]
-            pub static nsGkAtoms_lt_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8maction_E"]
-            pub static nsGkAtoms_maction_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12maligngroup_E"]
-            pub static nsGkAtoms_maligngroup_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11malignmark_E"]
-            pub static nsGkAtoms_malignmark_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15mathbackground_E"]
-            pub static nsGkAtoms_mathbackground_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10mathcolor_E"]
-            pub static nsGkAtoms_mathcolor_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9mathsize_E"]
-            pub static nsGkAtoms_mathsize_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12mathvariant_E"]
-            pub static nsGkAtoms_mathvariant_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10matrixrow_E"]
-            pub static nsGkAtoms_matrixrow_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8maxsize_E"]
-            pub static nsGkAtoms_maxsize_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5mean_E"]
-            pub static nsGkAtoms_mean_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7median_E"]
-            pub static nsGkAtoms_median_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9menclose_E"]
-            pub static nsGkAtoms_menclose_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7merror_E"]
-            pub static nsGkAtoms_merror_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8mfenced_E"]
-            pub static nsGkAtoms_mfenced_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6mfrac_E"]
-            pub static nsGkAtoms_mfrac_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7mglyph_E"]
-            pub static nsGkAtoms_mglyph_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3mi_E"]
-            pub static nsGkAtoms_mi_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16minlabelspacing_E"]
-            pub static nsGkAtoms_minlabelspacing_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8minsize_E"]
-            pub static nsGkAtoms_minsize_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6minus_E"]
-            pub static nsGkAtoms_minus_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11mlabeledtr_E"]
-            pub static nsGkAtoms_mlabeledtr_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9mlongdiv_E"]
-            pub static nsGkAtoms_mlongdiv_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14mmultiscripts_E"]
-            pub static nsGkAtoms_mmultiscripts_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3mn_E"]
-            pub static nsGkAtoms_mn_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12momentabout_E"]
-            pub static nsGkAtoms_momentabout_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7moment_E"]
-            pub static nsGkAtoms_moment_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3mo_E"]
-            pub static nsGkAtoms_mo_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14movablelimits_E"]
-            pub static nsGkAtoms_movablelimits_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6mover_E"]
-            pub static nsGkAtoms_mover_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8mpadded_E"]
-            pub static nsGkAtoms_mpadded_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9mphantom_E"]
-            pub static nsGkAtoms_mphantom_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12mprescripts_E"]
-            pub static nsGkAtoms_mprescripts_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6mroot_E"]
-            pub static nsGkAtoms_mroot_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5mrow_E"]
-            pub static nsGkAtoms_mrow_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10mscarries_E"]
-            pub static nsGkAtoms_mscarries_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8mscarry_E"]
-            pub static nsGkAtoms_mscarry_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8msgroup_E"]
-            pub static nsGkAtoms_msgroup_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7msline_E"]
-            pub static nsGkAtoms_msline_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3ms_E"]
-            pub static nsGkAtoms_ms_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7mspace_E"]
-            pub static nsGkAtoms_mspace_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6msqrt_E"]
-            pub static nsGkAtoms_msqrt_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6msrow_E"]
-            pub static nsGkAtoms_msrow_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7mstack_E"]
-            pub static nsGkAtoms_mstack_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7mstyle_E"]
-            pub static nsGkAtoms_mstyle_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5msub_E"]
-            pub static nsGkAtoms_msub_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8msubsup_E"]
-            pub static nsGkAtoms_msubsup_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5msup_E"]
-            pub static nsGkAtoms_msup_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7mtable_E"]
-            pub static nsGkAtoms_mtable_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4mtd_E"]
-            pub static nsGkAtoms_mtd_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6mtext_E"]
-            pub static nsGkAtoms_mtext_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4mtr_E"]
-            pub static nsGkAtoms_mtr_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7munder_E"]
-            pub static nsGkAtoms_munder_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11munderover_E"]
-            pub static nsGkAtoms_munderover_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15naturalnumbers_E"]
-            pub static nsGkAtoms_naturalnumbers_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4neq_E"]
-            pub static nsGkAtoms_neq_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11notanumber_E"]
-            pub static nsGkAtoms_notanumber_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9notation_E"]
-            pub static nsGkAtoms_notation_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5note_E"]
-            pub static nsGkAtoms_note_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6notin_E"]
-            pub static nsGkAtoms_notin_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12notprsubset_E"]
-            pub static nsGkAtoms_notprsubset_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10notsubset_E"]
-            pub static nsGkAtoms_notsubset_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9numalign_E"]
-            pub static nsGkAtoms_numalign_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5otherE"]
-            pub static nsGkAtoms_other: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13outerproduct_E"]
-            pub static nsGkAtoms_outerproduct_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12partialdiff_E"]
-            pub static nsGkAtoms_partialdiff_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6piece_E"]
-            pub static nsGkAtoms_piece_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10piecewise_E"]
-            pub static nsGkAtoms_piecewise_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3pi_E"]
-            pub static nsGkAtoms_pi_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5plus_E"]
-            pub static nsGkAtoms_plus_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6power_E"]
-            pub static nsGkAtoms_power_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7primes_E"]
-            pub static nsGkAtoms_primes_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8product_E"]
-            pub static nsGkAtoms_product_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9prsubset_E"]
-            pub static nsGkAtoms_prsubset_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9quotient_E"]
-            pub static nsGkAtoms_quotient_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10rationals_E"]
-            pub static nsGkAtoms_rationals_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5real_E"]
-            pub static nsGkAtoms_real_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6reals_E"]
-            pub static nsGkAtoms_reals_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5reln_E"]
-            pub static nsGkAtoms_reln_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5root_E"]
-            pub static nsGkAtoms_root_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9rowalign_E"]
-            pub static nsGkAtoms_rowalign_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9rowlines_E"]
-            pub static nsGkAtoms_rowlines_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11rowspacing_E"]
-            pub static nsGkAtoms_rowspacing_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7rquote_E"]
-            pub static nsGkAtoms_rquote_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7rspace_E"]
-            pub static nsGkAtoms_rspace_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14scalarproduct_E"]
-            pub static nsGkAtoms_scalarproduct_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15schemaLocation_E"]
-            pub static nsGkAtoms_schemaLocation_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12scriptlevel_E"]
-            pub static nsGkAtoms_scriptlevel_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14scriptminsize_E"]
-            pub static nsGkAtoms_scriptminsize_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21scriptsizemultiplier_E"]
-            pub static nsGkAtoms_scriptsizemultiplier_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11scriptsize_E"]
-            pub static nsGkAtoms_scriptsize_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5sdev_E"]
-            pub static nsGkAtoms_sdev_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5sech_E"]
-            pub static nsGkAtoms_sech_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4sec_E"]
-            pub static nsGkAtoms_sec_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10selection_E"]
-            pub static nsGkAtoms_selection_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9selector_E"]
-            pub static nsGkAtoms_selector_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10semantics_E"]
-            pub static nsGkAtoms_semantics_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10separator_E"]
-            pub static nsGkAtoms_separator_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11separators_E"]
-            pub static nsGkAtoms_separators_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4sep_E"]
-            pub static nsGkAtoms_sep_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8setdiff_E"]
-            pub static nsGkAtoms_setdiff_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6share_E"]
-            pub static nsGkAtoms_share_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6shift_E"]
-            pub static nsGkAtoms_shift_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5side_E"]
-            pub static nsGkAtoms_side_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5sinh_E"]
-            pub static nsGkAtoms_sinh_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4sin_E"]
-            pub static nsGkAtoms_sin_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11stackalign_E"]
-            pub static nsGkAtoms_stackalign_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9stretchy_E"]
-            pub static nsGkAtoms_stretchy_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15subscriptshift_E"]
-            pub static nsGkAtoms_subscriptshift_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7subset_E"]
-            pub static nsGkAtoms_subset_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17superscriptshift_E"]
-            pub static nsGkAtoms_superscriptshift_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10symmetric_E"]
-            pub static nsGkAtoms_symmetric_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5tanh_E"]
-            pub static nsGkAtoms_tanh_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4tan_E"]
-            pub static nsGkAtoms_tan_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8tendsto_E"]
-            pub static nsGkAtoms_tendsto_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6times_E"]
-            pub static nsGkAtoms_times_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10transpose_E"]
-            pub static nsGkAtoms_transpose_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6union_E"]
-            pub static nsGkAtoms_union_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8uplimit_E"]
-            pub static nsGkAtoms_uplimit_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9variance_E"]
-            pub static nsGkAtoms_variance_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14vectorproduct_E"]
-            pub static nsGkAtoms_vectorproduct_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7vector_E"]
-            pub static nsGkAtoms_vector_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8voffset_E"]
-            pub static nsGkAtoms_voffset_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5xref_E"]
-            pub static nsGkAtoms_xref_: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4mathE"]
-            pub static nsGkAtoms_math: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3avgE"]
-            pub static nsGkAtoms_avg: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17booleanFromStringE"]
-            pub static nsGkAtoms_booleanFromString: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13countNonEmptyE"]
-            pub static nsGkAtoms_countNonEmpty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12daysFromDateE"]
-            pub static nsGkAtoms_daysFromDate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4initE"]
-            pub static nsGkAtoms_init: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8instanceE"]
-            pub static nsGkAtoms_instance: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6monthsE"]
-            pub static nsGkAtoms_months: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms3nowE"]
-            pub static nsGkAtoms_now: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7secondsE"]
-            pub static nsGkAtoms_seconds: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19secondsFromDateTimeE"]
-            pub static nsGkAtoms_secondsFromDateTime: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms25onMozSwipeGestureMayStartE"]
-            pub static nsGkAtoms_onMozSwipeGestureMayStart: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms22onMozSwipeGestureStartE"]
-            pub static nsGkAtoms_onMozSwipeGestureStart: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms23onMozSwipeGestureUpdateE"]
-            pub static nsGkAtoms_onMozSwipeGestureUpdate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20onMozSwipeGestureEndE"]
-            pub static nsGkAtoms_onMozSwipeGestureEnd: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17onMozSwipeGestureE"]
-            pub static nsGkAtoms_onMozSwipeGesture: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24onMozMagnifyGestureStartE"]
-            pub static nsGkAtoms_onMozMagnifyGestureStart: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms25onMozMagnifyGestureUpdateE"]
-            pub static nsGkAtoms_onMozMagnifyGestureUpdate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19onMozMagnifyGestureE"]
-            pub static nsGkAtoms_onMozMagnifyGesture: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms23onMozRotateGestureStartE"]
-            pub static nsGkAtoms_onMozRotateGestureStart: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24onMozRotateGestureUpdateE"]
-            pub static nsGkAtoms_onMozRotateGestureUpdate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18onMozRotateGestureE"]
-            pub static nsGkAtoms_onMozRotateGesture: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15onMozTapGestureE"]
-            pub static nsGkAtoms_onMozTapGesture: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20onMozPressTapGestureE"]
-            pub static nsGkAtoms_onMozPressTapGesture: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18onMozEdgeUIStartedE"]
-            pub static nsGkAtoms_onMozEdgeUIStarted: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19onMozEdgeUICanceledE"]
-            pub static nsGkAtoms_onMozEdgeUICanceled: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20onMozEdgeUICompletedE"]
-            pub static nsGkAtoms_onMozEdgeUICompleted: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onpointerdownE"]
-            pub static nsGkAtoms_onpointerdown: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onpointermoveE"]
-            pub static nsGkAtoms_onpointermove: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11onpointerupE"]
-            pub static nsGkAtoms_onpointerup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15onpointercancelE"]
-            pub static nsGkAtoms_onpointercancel: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onpointeroverE"]
-            pub static nsGkAtoms_onpointerover: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12onpointeroutE"]
-            pub static nsGkAtoms_onpointerout: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14onpointerenterE"]
-            pub static nsGkAtoms_onpointerenter: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14onpointerleaveE"]
-            pub static nsGkAtoms_onpointerleave: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19ongotpointercaptureE"]
-            pub static nsGkAtoms_ongotpointercapture: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20onlostpointercaptureE"]
-            pub static nsGkAtoms_onlostpointercapture: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14ondevicemotionE"]
-            pub static nsGkAtoms_ondevicemotion: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19ondeviceorientationE"]
-            pub static nsGkAtoms_ondeviceorientation: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms27onabsolutedeviceorientationE"]
-            pub static nsGkAtoms_onabsolutedeviceorientation: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17ondeviceproximityE"]
-            pub static nsGkAtoms_ondeviceproximity: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms22onmozorientationchangeE"]
-            pub static nsGkAtoms_onmozorientationchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15onuserproximityE"]
-            pub static nsGkAtoms_onuserproximity: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13ondevicelightE"]
-            pub static nsGkAtoms_ondevicelight: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14ondevicechangeE"]
-            pub static nsGkAtoms_ondevicechange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13moz_extensionE"]
-            pub static nsGkAtoms_moz_extension: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18all_urlsPermissionE"]
-            pub static nsGkAtoms_all_urlsPermission: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13clipboardReadE"]
-            pub static nsGkAtoms_clipboardRead: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14clipboardWriteE"]
-            pub static nsGkAtoms_clipboardWrite: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8debuggerE"]
-            pub static nsGkAtoms_debugger: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4tabsE"]
-            pub static nsGkAtoms_tabs: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18webRequestBlockingE"]
-            pub static nsGkAtoms_webRequestBlocking: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4httpE"]
-            pub static nsGkAtoms_http: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5httpsE"]
-            pub static nsGkAtoms_https: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5proxyE"]
-            pub static nsGkAtoms_proxy: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12cdataTagNameE"]
-            pub static nsGkAtoms_cdataTagName: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14commentTagNameE"]
-            pub static nsGkAtoms_commentTagName: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16documentNodeNameE"]
-            pub static nsGkAtoms_documentNodeName: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24documentFragmentNodeNameE"]
-            pub static nsGkAtoms_documentFragmentNodeName: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20documentTypeNodeNameE"]
-            pub static nsGkAtoms_documentTypeNodeName: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms28processingInstructionTagNameE"]
-            pub static nsGkAtoms_processingInstructionTagName: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11textTagNameE"]
-            pub static nsGkAtoms_textTagName: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16placeholderFrameE"]
-            pub static nsGkAtoms_placeholderFrame: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onloadendE"]
-            pub static nsGkAtoms_onloadend: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11onloadstartE"]
-            pub static nsGkAtoms_onloadstart: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onprogressE"]
-            pub static nsGkAtoms_onprogress: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onsuspendE"]
-            pub static nsGkAtoms_onsuspend: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onemptiedE"]
-            pub static nsGkAtoms_onemptied: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onstalledE"]
-            pub static nsGkAtoms_onstalled: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6onplayE"]
-            pub static nsGkAtoms_onplay: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7onpauseE"]
-            pub static nsGkAtoms_onpause: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16onloadedmetadataE"]
-            pub static nsGkAtoms_onloadedmetadata: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12onloadeddataE"]
-            pub static nsGkAtoms_onloadeddata: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onwaitingE"]
-            pub static nsGkAtoms_onwaiting: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onplayingE"]
-            pub static nsGkAtoms_onplaying: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9oncanplayE"]
-            pub static nsGkAtoms_oncanplay: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16oncanplaythroughE"]
-            pub static nsGkAtoms_oncanplaythrough: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onseekingE"]
-            pub static nsGkAtoms_onseeking: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8onseekedE"]
-            pub static nsGkAtoms_onseeked: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9ontimeoutE"]
-            pub static nsGkAtoms_ontimeout: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12ontimeupdateE"]
-            pub static nsGkAtoms_ontimeupdate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7onendedE"]
-            pub static nsGkAtoms_onended: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12onratechangeE"]
-            pub static nsGkAtoms_onratechange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16ondurationchangeE"]
-            pub static nsGkAtoms_ondurationchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14onvolumechangeE"]
-            pub static nsGkAtoms_onvolumechange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10onaddtrackE"]
-            pub static nsGkAtoms_onaddtrack: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18oncontrollerchangeE"]
-            pub static nsGkAtoms_oncontrollerchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11oncuechangeE"]
-            pub static nsGkAtoms_oncuechange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7onenterE"]
-            pub static nsGkAtoms_onenter: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6onexitE"]
-            pub static nsGkAtoms_onexit: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms11onencryptedE"]
-            pub static nsGkAtoms_onencrypted: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9encryptedE"]
-            pub static nsGkAtoms_encrypted: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15onwaitingforkeyE"]
-            pub static nsGkAtoms_onwaitingforkey: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19onkeystatuseschangeE"]
-            pub static nsGkAtoms_onkeystatuseschange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms13onremovetrackE"]
-            pub static nsGkAtoms_onremovetrack: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9loadstartE"]
-            pub static nsGkAtoms_loadstart: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7suspendE"]
-            pub static nsGkAtoms_suspend: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7emptiedE"]
-            pub static nsGkAtoms_emptied: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7stalledE"]
-            pub static nsGkAtoms_stalled: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms4playE"]
-            pub static nsGkAtoms_play: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5pauseE"]
-            pub static nsGkAtoms_pause: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14loadedmetadataE"]
-            pub static nsGkAtoms_loadedmetadata: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10loadeddataE"]
-            pub static nsGkAtoms_loadeddata: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7waitingE"]
-            pub static nsGkAtoms_waiting: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7playingE"]
-            pub static nsGkAtoms_playing: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7seekingE"]
-            pub static nsGkAtoms_seeking: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6seekedE"]
-            pub static nsGkAtoms_seeked: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10timeupdateE"]
-            pub static nsGkAtoms_timeupdate: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5endedE"]
-            pub static nsGkAtoms_ended: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7canplayE"]
-            pub static nsGkAtoms_canplay: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14canplaythroughE"]
-            pub static nsGkAtoms_canplaythrough: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10ratechangeE"]
-            pub static nsGkAtoms_ratechange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14durationchangeE"]
-            pub static nsGkAtoms_durationchange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12volumechangeE"]
-            pub static nsGkAtoms_volumechange: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15ondataavailableE"]
-            pub static nsGkAtoms_ondataavailable: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9onwarningE"]
-            pub static nsGkAtoms_onwarning: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7onstartE"]
-            pub static nsGkAtoms_onstart: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6onstopE"]
-            pub static nsGkAtoms_onstop: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7onphotoE"]
-            pub static nsGkAtoms_onphoto: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20onactivestatechangedE"]
-            pub static nsGkAtoms_onactivestatechanged: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19ongamepadbuttondownE"]
-            pub static nsGkAtoms_ongamepadbuttondown: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17ongamepadbuttonupE"]
-            pub static nsGkAtoms_ongamepadbuttonup: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17ongamepadaxismoveE"]
-            pub static nsGkAtoms_ongamepadaxismove: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18ongamepadconnectedE"]
-            pub static nsGkAtoms_ongamepadconnected: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms21ongamepaddisconnectedE"]
-            pub static nsGkAtoms_ongamepaddisconnected: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19afterPseudoPropertyE"]
-            pub static nsGkAtoms_afterPseudoProperty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms18animationsPropertyE"]
-            pub static nsGkAtoms_animationsProperty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms26animationsOfBeforePropertyE"]
-            pub static nsGkAtoms_animationsOfBeforeProperty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms25animationsOfAfterPropertyE"]
-            pub static nsGkAtoms_animationsOfAfterProperty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24animationEffectsPropertyE"]
-            pub static nsGkAtoms_animationEffectsProperty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms33animationEffectsForBeforePropertyE"]
-            pub static nsGkAtoms_animationEffectsForBeforeProperty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms32animationEffectsForAfterPropertyE"]
-            pub static nsGkAtoms_animationEffectsForAfterProperty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20beforePseudoPropertyE"]
-            pub static nsGkAtoms_beforePseudoProperty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms30cssPseudoElementBeforePropertyE"]
-            pub static nsGkAtoms_cssPseudoElementBeforeProperty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms29cssPseudoElementAfterPropertyE"]
-            pub static nsGkAtoms_cssPseudoElementAfterProperty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms19transitionsPropertyE"]
-            pub static nsGkAtoms_transitionsProperty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms27transitionsOfBeforePropertyE"]
-            pub static nsGkAtoms_transitionsOfBeforeProperty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms26transitionsOfAfterPropertyE"]
-            pub static nsGkAtoms_transitionsOfAfterProperty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms25genConInitializerPropertyE"]
-            pub static nsGkAtoms_genConInitializerProperty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms24labelMouseDownPtPropertyE"]
-            pub static nsGkAtoms_labelMouseDownPtProperty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17lockedStyleStatesE"]
-            pub static nsGkAtoms_lockedStyleStates: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms20apzCallbackTransformE"]
-            pub static nsGkAtoms_apzCallbackTransform: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms23restylableAnonymousNodeE"]
-            pub static nsGkAtoms_restylableAnonymousNode: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms30docLevelNativeAnonymousContentE"]
-            pub static nsGkAtoms_docLevelNativeAnonymousContent: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms16paintRequestTimeE"]
-            pub static nsGkAtoms_paintRequestTime: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms14pseudoPropertyE"]
-            pub static nsGkAtoms_pseudoProperty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms17manualNACPropertyE"]
-            pub static nsGkAtoms_manualNACProperty: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms8JapaneseE"]
-            pub static nsGkAtoms_Japanese: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7ChineseE"]
-            pub static nsGkAtoms_Chinese: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms9TaiwaneseE"]
-            pub static nsGkAtoms_Taiwanese: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms15HongKongChineseE"]
-            pub static nsGkAtoms_HongKongChinese: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7UnicodeE"]
-            pub static nsGkAtoms_Unicode: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2koE"]
-            pub static nsGkAtoms_ko: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5zh_cnE"]
-            pub static nsGkAtoms_zh_cn: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5zh_hkE"]
-            pub static nsGkAtoms_zh_hk: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms5zh_twE"]
-            pub static nsGkAtoms_zh_tw: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms10x_cyrillicE"]
-            pub static nsGkAtoms_x_cyrillic: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2heE"]
-            pub static nsGkAtoms_he: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms2arE"]
-            pub static nsGkAtoms_ar: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms12x_devanagariE"]
-            pub static nsGkAtoms_x_devanagari: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms7x_tamilE"]
-            pub static nsGkAtoms_x_tamil: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6x_armnE"]
-            pub static nsGkAtoms_x_armn: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6x_bengE"]
-            pub static nsGkAtoms_x_beng: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6x_cansE"]
-            pub static nsGkAtoms_x_cans: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6x_ethiE"]
-            pub static nsGkAtoms_x_ethi: *mut nsStaticAtom;
-            #[link_name = "_ZN9nsGkAtoms6x_g