experimental/PdfViewer/pdf_auto_gen.h

Index: experimental/PdfViewer/pdf_auto_gen.h
===================================================================
--- experimental/PdfViewer/pdf_auto_gen.h	(revision 9644)
+++ experimental/PdfViewer/pdf_auto_gen.h	(working copy)
@@ -7479,39 +7479,120 @@
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
-  SkPdfObject* Filter() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
-    return NULL;
+  bool isFilterAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  SkPdfObject* DecodeParms() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DecodeParms", "", &ret)) return ret;
-    return NULL;
+  std::string getFilterAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
-  SkPdfObject* F() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    return NULL;
+  bool isFilterAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfObject* FFilter() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FFilter", "", &ret)) return ret;
+  SkPdfArray getFilterAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
+  bool isDecodeParmsADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DecodeParms", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
+  }
+
+  SkPdfDictionary* getDecodeParmsAsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DecodeParms", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* FDecodeParms() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDecodeParms", "", &ret)) return ret;
+  bool isDecodeParmsAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DecodeParms", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
+  }
+
+  SkPdfArray getDecodeParmsAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DecodeParms", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
+  SkPdfFileSpec F() const {
+    SkPdfFileSpec ret;
+    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfFileSpec();
+  }
+
+  bool isFFilterAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FFilter", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getFFilterAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FFilter", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isFFilterAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FFilter", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
+  }
+
+  SkPdfArray getFFilterAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FFilter", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
+  bool isFDecodeParmsADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDecodeParms", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
+  }
+
+  SkPdfDictionary* getFDecodeParmsAsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDecodeParms", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
+  bool isFDecodeParmsAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDecodeParms", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
+  }
+
+  SkPdfArray getFDecodeParmsAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDecodeParms", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
 };
 
 
@@ -8034,30 +8115,35 @@
   long Predictor() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Predictor", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long Colors() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colors", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long BitsPerComponent() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long Columns() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Columns", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long EarlyChange() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EarlyChange", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -8583,48 +8669,56 @@
   long K() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* EndOfLine() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndOfLine", "", &ret)) return ret;
-    return NULL;
+  bool EndOfLine() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndOfLine", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
-  SkPdfObject* EncodedByteAlign() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EncodedByteAlign", "", &ret)) return ret;
-    return NULL;
+  bool EncodedByteAlign() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EncodedByteAlign", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
   long Columns() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Columns", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long Rows() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rows", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* EndOfBlock() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndOfBlock", "", &ret)) return ret;
-    return NULL;
+  bool EndOfBlock() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndOfBlock", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
-  SkPdfObject* BlackIs1() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackIs1", "", &ret)) return ret;
-    return NULL;
+  bool BlackIs1() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackIs1", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
   long DamagedRowsBeforeError() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DamagedRowsBeforeError", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -9147,10 +9241,11 @@
 
   SkPdfJbig2DecodeFilterDictionary& operator=(const SkPdfJbig2DecodeFilterDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* JBIG2Globals() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JBIG2Globals", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream JBIG2Globals() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JBIG2Globals", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
 };
@@ -9675,6 +9770,7 @@
   long ColorTransform() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorTransform", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -10201,37 +10297,42 @@
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   long Prev() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Prev", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   SkPdfDictionary* Root() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Root", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* Encrypt() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encrypt", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* Info() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* ID() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray ID() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -10757,18 +10858,20 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   double V() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long Length() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -11295,28 +11398,28 @@
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   std::string O() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string U() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   long P() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
 };
@@ -11842,127 +11945,185 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Version() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   SkPdfDictionary* Pages() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* PageLabels() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLabels", "", &ret)) return ret;
+  bool isPageLabelsANumber() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLabels", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Real;
+  }
+
+  double getPageLabelsAsNumber() const {
+    double ret = 0;
+    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLabels", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return 0;
+  }
+
+  bool isPageLabelsATree() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLabels", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
+  }
+
+  SkPdfTree* getPageLabelsAsTree() const {
+    SkPdfTree* ret = NULL;
+    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLabels", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* Names() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Names", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* Dests() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* ViewerPreferences() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewerPreferences", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   std::string PageLayout() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLayout", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string PageMode() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageMode", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   SkPdfDictionary* Outlines() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Outlines", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* Threads() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Threads", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Threads() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Threads", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* OpenAction() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OpenAction", "", &ret)) return ret;
+  bool isOpenActionAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OpenAction", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
+  }
+
+  SkPdfArray getOpenActionAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OpenAction", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
+  bool isOpenActionADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OpenAction", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
+  }
+
+  SkPdfDictionary* getOpenActionAsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OpenAction", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* AA() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* URI() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URI", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* AcroForm() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AcroForm", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* Metadata() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream Metadata() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
   SkPdfDictionary* StructTreeRoot() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructTreeRoot", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* MarkInfo() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MarkInfo", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   std::string Lang() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   SkPdfDictionary* SpiderInfo() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpiderInfo", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* OutputIntents() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputIntents", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray OutputIntents() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputIntents", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -12488,27 +12649,28 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   SkPdfDictionary* Parent() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* Kids() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
+  SkPdfArray Kids() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
   long Count() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
 };
@@ -13034,19 +13196,21 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   SkPdfDictionary* Parent() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* LastModified() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
-    return NULL;
+  SkPdfDate LastModified() const {
+    SkPdfDate ret;
+    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfDate();
   }
 
   SkPdfDictionary* Resources() const {
@@ -13056,130 +13220,169 @@
     return NULL;
   }
 
-  SkPdfObject* MediaBox() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MediaBox", "", &ret)) return ret;
+  SkRect MediaBox() const {
+    SkRect ret;
+    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MediaBox", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkRect();
   }
 
-  SkPdfObject* CropBox() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CropBox", "", &ret)) return ret;
-    return NULL;
+  SkRect CropBox() const {
+    SkRect ret;
+    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CropBox", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkRect();
   }
 
-  SkPdfObject* BleedBox() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BleedBox", "", &ret)) return ret;
-    return NULL;
+  SkRect BleedBox() const {
+    SkRect ret;
+    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BleedBox", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkRect();
   }
 
-  SkPdfObject* TrimBox() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrimBox", "", &ret)) return ret;
-    return NULL;
+  SkRect TrimBox() const {
+    SkRect ret;
+    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrimBox", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkRect();
   }
 
-  SkPdfObject* ArtBox() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ArtBox", "", &ret)) return ret;
-    return NULL;
+  SkRect ArtBox() const {
+    SkRect ret;
+    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ArtBox", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkRect();
   }
 
   SkPdfDictionary* BoxColorInfo() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BoxColorInfo", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* Contents() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
-    return NULL;
+  bool isContentsAStream() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return false;
+    return ret->podofo()->HasStream();
   }
 
+  SkPdfStream getContentsAsStream() const {
+    SkPdfStream ret = SkPdfStream();
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
+  }
+
+  bool isContentsAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
+  }
+
+  SkPdfArray getContentsAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
   long Rotate() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rotate", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   SkPdfDictionary* Group() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Group", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* Thumb() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Thumb", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream Thumb() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Thumb", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
-  SkPdfObject* B() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray B() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   double Dur() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dur", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   SkPdfDictionary* Trans() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Trans", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* Annots() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annots", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Annots() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annots", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   SkPdfDictionary* AA() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* Metadata() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream Metadata() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
   SkPdfDictionary* PieceInfo() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PieceInfo", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   long StructParents() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   std::string ID() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   double PZ() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PZ", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   SkPdfDictionary* SeparationInfo() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SeparationInfo", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -13702,51 +13905,211 @@
 
   SkPdfNameDictionary& operator=(const SkPdfNameDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* Dests() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", &ret)) return ret;
+  bool isDestsAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getDestsAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isDestsATree() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
+  }
+
+  SkPdfTree* getDestsAsTree() const {
+    SkPdfTree* ret = NULL;
+    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* AP() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
+  bool isAPAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getAPAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isAPATree() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
+  }
+
+  SkPdfTree* getAPAsTree() const {
+    SkPdfTree* ret = NULL;
+    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* JavaScript() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", &ret)) return ret;
+  bool isJavaScriptAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getJavaScriptAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isJavaScriptATree() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
+  }
+
+  SkPdfTree* getJavaScriptAsTree() const {
+    SkPdfTree* ret = NULL;
+    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* Pages() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
+  bool isPagesAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getPagesAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isPagesATree() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
+  }
+
+  SkPdfTree* getPagesAsTree() const {
+    SkPdfTree* ret = NULL;
+    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* Templates() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return ret;
+  bool isTemplatesAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getTemplatesAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isTemplatesATree() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
+  }
+
+  SkPdfTree* getTemplatesAsTree() const {
+    SkPdfTree* ret = NULL;
+    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* IDS() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDS", "", &ret)) return ret;
+  bool isIDSAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDS", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getIDSAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDS", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isIDSATree() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDS", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
+  }
+
+  SkPdfTree* getIDSAsTree() const {
+    SkPdfTree* ret = NULL;
+    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDS", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* URLS() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URLS", "", &ret)) return ret;
+  bool isURLSAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URLS", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getURLSAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URLS", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isURLSATree() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URLS", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
+  }
+
+  SkPdfTree* getURLSAsTree() const {
+    SkPdfTree* ret = NULL;
+    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URLS", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* EmbeddedFiles() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFiles", "", &ret)) return ret;
+  bool isEmbeddedFilesAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFiles", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getEmbeddedFilesAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFiles", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isEmbeddedFilesATree() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFiles", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
+  }
+
+  SkPdfTree* getEmbeddedFilesAsTree() const {
+    SkPdfTree* ret = NULL;
+    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFiles", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -14272,48 +14635,56 @@
   SkPdfDictionary* ExtGState() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ExtGState", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* ColorSpace() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* Pattern() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pattern", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* Shading() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* XObject() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "XObject", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream XObject() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "XObject", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
   SkPdfDictionary* Font() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Font", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* ProcSet() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ProcSet", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray ProcSet() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ProcSet", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   SkPdfDictionary* Properties() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Properties", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -14836,22 +15207,25 @@
 
   SkPdfNameTreeNodeDictionary& operator=(const SkPdfNameTreeNodeDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* Kids() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Kids() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* Names() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Names", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Names() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Names", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* Limits() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Limits", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Limits() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Limits", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -15373,22 +15747,25 @@
 
   SkPdfNumberTreeNodeDictionary& operator=(const SkPdfNumberTreeNodeDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* Kids() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Kids() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* Nums() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Nums", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Nums() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Nums", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* Limits() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Limits", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Limits() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Limits", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -15914,20 +16291,21 @@
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FunctionType", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
-  SkPdfObject* Domain() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
+  SkPdfArray Domain() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
-  SkPdfObject* Range() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Range() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -16449,36 +16827,39 @@
 
   SkPdfType0FunctionDictionary& operator=(const SkPdfType0FunctionDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* Size() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", &ret)) return ret;
+  SkPdfArray Size() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
   long BitsPerSample() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerSample", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   long Order() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Order", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* Encode() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encode", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Encode() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encode", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* Decode() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Decode() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -17000,23 +17381,25 @@
 
   SkPdfType2FunctionDictionary& operator=(const SkPdfType2FunctionDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* C0() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C0", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray C0() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C0", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* C1() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C1", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray C1() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C1", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   double N() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
 };
@@ -17538,25 +17921,25 @@
 
   SkPdfType3FunctionDictionary& operator=(const SkPdfType3FunctionDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* Functions() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Functions", "", &ret)) return ret;
+  SkPdfArray Functions() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Functions", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
-  SkPdfObject* Bounds() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Bounds", "", &ret)) return ret;
+  SkPdfArray Bounds() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Bounds", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
-  SkPdfObject* Encode() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encode", "", &ret)) return ret;
+  SkPdfArray Encode() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encode", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
 };
@@ -18081,60 +18464,70 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string FS() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FS", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string F() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string DOS() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DOS", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string Mac() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string Unix() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Unix", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
-  SkPdfObject* ID() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray ID() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* V() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
-    return NULL;
+  bool V() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
   SkPdfDictionary* EF() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EF", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* RF() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RF", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -18660,18 +19053,21 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string Subtype() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   SkPdfDictionary* Params() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Params", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -19197,30 +19593,35 @@
   long Size() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* CreationDate() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CreationDate", "", &ret)) return ret;
-    return NULL;
+  SkPdfDate CreationDate() const {
+    SkPdfDate ret;
+    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CreationDate", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfDate();
   }
 
-  SkPdfObject* ModDate() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ModDate", "", &ret)) return ret;
-    return NULL;
+  SkPdfDate ModDate() const {
+    SkPdfDate ret;
+    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ModDate", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfDate();
   }
 
   SkPdfDictionary* Mac() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   std::string CheckSum() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CheckSum", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
@@ -19746,19 +20147,22 @@
   std::string Subtype() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string Creator() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Creator", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
-  SkPdfObject* ResFork() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ResFork", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream ResFork() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ResFork", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
 };
@@ -20283,163 +20687,362 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   double LW() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LW", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long LC() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LC", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long LJ() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LJ", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   double ML() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ML", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* D() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray D() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   std::string RI() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RI", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
-  SkPdfObject* OP() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OP", "", &ret)) return ret;
-    return NULL;
+  bool OP() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OP", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
-  SkPdfObject* op() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "op", "", &ret)) return ret;
-    return NULL;
+  bool op() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "op", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
   long OPM() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPM", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* Font() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Font", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Font() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Font", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* BG() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG", "", &ret)) return ret;
-    return NULL;
+  SkPdfFunction BG() const {
+    SkPdfFunction ret;
+    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfFunction();
   }
 
-  SkPdfObject* BG2() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG2", "", &ret)) return ret;
-    return NULL;
+  bool isBG2AFunction() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG2", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfObject* UCR() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR", "", &ret)) return ret;
-    return NULL;
+  SkPdfFunction getBG2AsFunction() const {
+    SkPdfFunction ret = SkPdfFunction();
+    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG2", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfFunction();
   }
 
-  SkPdfObject* UCR2() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR2", "", &ret)) return ret;
-    return NULL;
+  bool isBG2AName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG2", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  SkPdfObject* TR() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
-    return NULL;
+  std::string getBG2AsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG2", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
-  SkPdfObject* TR2() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return ret;
-    return NULL;
+  SkPdfFunction UCR() const {
+    SkPdfFunction ret;
+    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfFunction();
   }
 
-  SkPdfObject* HT() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return ret;
+  bool isUCR2AFunction() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR2", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
+  }
+
+  SkPdfFunction getUCR2AsFunction() const {
+    SkPdfFunction ret = SkPdfFunction();
+    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR2", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfFunction();
+  }
+
+  bool isUCR2AName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR2", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getUCR2AsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR2", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isTRAFunction() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
+  }
+
+  SkPdfFunction getTRAsFunction() const {
+    SkPdfFunction ret = SkPdfFunction();
+    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfFunction();
+  }
+
+  bool isTRAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
+  }
+
+  SkPdfArray getTRAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
+  bool isTRAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getTRAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isTR2AFunction() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
+  }
+
+  SkPdfFunction getTR2AsFunction() const {
+    SkPdfFunction ret = SkPdfFunction();
+    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfFunction();
+  }
+
+  bool isTR2AArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
+  }
+
+  SkPdfArray getTR2AsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
+  bool isTR2AName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getTR2AsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isHTADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
+  }
+
+  SkPdfDictionary* getHTAsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
+  bool isHTAStream() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return false;
+    return ret->podofo()->HasStream();
+  }
+
+  SkPdfStream getHTAsStream() const {
+    SkPdfStream ret = SkPdfStream();
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
+  }
+
+  bool isHTAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getHTAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
   double FL() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FL", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   double SM() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SM", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* SA() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SA", "", &ret)) return ret;
-    return NULL;
+  bool SA() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SA", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
-  SkPdfObject* BM() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BM", "", &ret)) return ret;
-    return NULL;
+  bool isBMAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BM", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  SkPdfObject* SMask() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return ret;
+  std::string getBMAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BM", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isBMAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BM", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
+  }
+
+  SkPdfArray getBMAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BM", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
+  bool isSMaskADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
+  }
+
+  SkPdfDictionary* getSMaskAsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
+  bool isSMaskAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getSMaskAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
   double CA() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   double ca() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ca", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* AIS() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AIS", "", &ret)) return ret;
-    return NULL;
+  bool AIS() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AIS", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
-  SkPdfObject* TK() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TK", "", &ret)) return ret;
-    return NULL;
+  bool TK() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TK", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
 };
@@ -20961,22 +21564,24 @@
 
   SkPdfCalgrayColorSpaceDictionary& operator=(const SkPdfCalgrayColorSpaceDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* WhitePoint() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", &ret)) return ret;
+  SkPdfArray WhitePoint() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
-  SkPdfObject* BlackPoint() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray BlackPoint() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   double Gamma() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Gamma", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -21499,29 +22104,32 @@
 
   SkPdfCalrgbColorSpaceDictionary& operator=(const SkPdfCalrgbColorSpaceDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* WhitePoint() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", &ret)) return ret;
+  SkPdfArray WhitePoint() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
-  SkPdfObject* BlackPoint() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray BlackPoint() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* Gamma() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Gamma", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Gamma() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Gamma", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* Matrix() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Matrix() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -22043,23 +22651,25 @@
 
   SkPdfLabColorSpaceDictionary& operator=(const SkPdfLabColorSpaceDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* WhitePoint() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", &ret)) return ret;
+  SkPdfArray WhitePoint() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
-  SkPdfObject* BlackPoint() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray BlackPoint() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* Range() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Range() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -22585,27 +23195,49 @@
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
-  SkPdfObject* Alternate() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternate", "", &ret)) return ret;
-    return NULL;
+  bool isAlternateAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternate", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfObject* Range() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray getAlternateAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternate", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* Metadata() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
-    return NULL;
+  bool isAlternateAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternate", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
+  std::string getAlternateAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternate", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  SkPdfArray Range() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
+  SkPdfStream Metadata() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
+  }
+
 };
 
 
@@ -23128,6 +23760,7 @@
   SkPdfDictionary* Colorants() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colorants", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -23653,21 +24286,22 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   long PatternType() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PatternType", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   long PaintType() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PaintType", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
 };
@@ -24192,6 +24826,7 @@
   long Type() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -24199,25 +24834,46 @@
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PatternType", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
-  SkPdfObject* Shading() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", &ret)) return ret;
+  bool isShadingADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
+  }
+
+  SkPdfDictionary* getShadingAsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* Matrix() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
-    return NULL;
+  bool isShadingAStream() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", &ret)) return false;
+    return ret->podofo()->HasStream();
   }
 
+  SkPdfStream getShadingAsStream() const {
+    SkPdfStream ret = SkPdfStream();
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
+  }
+
+  SkPdfArray Matrix() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
   SkPdfDictionary* ExtGState() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ExtGState", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -24726,34 +25382,56 @@
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ShadingType", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
-  SkPdfObject* ColorSpace() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
+  bool isColorSpaceAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getColorSpaceAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* Background() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Background", "", &ret)) return ret;
-    return NULL;
+  bool isColorSpaceAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfObject* BBox() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray getColorSpaceAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* AntiAlias() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AntiAlias", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Background() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Background", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
+  SkRect BBox() const {
+    SkRect ret;
+    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkRect();
+  }
+
+  bool AntiAlias() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AntiAlias", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
+  }
+
 };
 
 
@@ -24790,23 +25468,25 @@
 
   SkPdfType1ShadingDictionary& operator=(const SkPdfType1ShadingDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* Domain() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Domain() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* Matrix() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Matrix() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* Function() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
+  SkPdfFunction Function() const {
+    SkPdfFunction ret;
+    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfFunction();
   }
 
 };
@@ -24845,30 +25525,32 @@
 
   SkPdfType2ShadingDictionary& operator=(const SkPdfType2ShadingDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* Coords() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Coords", "", &ret)) return ret;
+  SkPdfArray Coords() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Coords", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
-  SkPdfObject* Domain() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Domain() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* Function() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
+  SkPdfFunction Function() const {
+    SkPdfFunction ret;
+    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfFunction();
   }
 
-  SkPdfObject* Extend() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Extend", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Extend() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Extend", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -24907,30 +25589,32 @@
 
   SkPdfType3ShadingDictionary& operator=(const SkPdfType3ShadingDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* Coords() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Coords", "", &ret)) return ret;
+  SkPdfArray Coords() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Coords", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
-  SkPdfObject* Domain() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Domain() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* Function() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
+  SkPdfFunction Function() const {
+    SkPdfFunction ret;
+    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfFunction();
   }
 
-  SkPdfObject* Extend() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Extend", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Extend() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Extend", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -24973,34 +25657,35 @@
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   long BitsPerComponent() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   long BitsPerFlag() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerFlag", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
-  SkPdfObject* Decode() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
+  SkRect Decode() const {
+    SkRect ret;
+    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkRect();
   }
 
-  SkPdfObject* Function() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
-    return NULL;
+  SkPdfFunction Function() const {
+    SkPdfFunction ret;
+    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfFunction();
   }
 
 };
@@ -25043,34 +25728,35 @@
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   long BitsPerComponent() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   long VerticesPerRow() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "VerticesPerRow", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
-  SkPdfObject* Decode() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
+  SkPdfArray Decode() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
-  SkPdfObject* Function() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
-    return NULL;
+  SkPdfFunction Function() const {
+    SkPdfFunction ret;
+    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfFunction();
   }
 
 };
@@ -25113,34 +25799,35 @@
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   long BitsPerComponent() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   long BitsPerFlag() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerFlag", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
-  SkPdfObject* Decode() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
+  SkPdfArray Decode() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
-  SkPdfObject* Function() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
-    return NULL;
+  SkPdfFunction Function() const {
+    SkPdfFunction ret;
+    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfFunction();
   }
 
 };
@@ -25170,112 +25857,165 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string Subtype() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   long Width() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   long Height() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
-  SkPdfObject* ColorSpace() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
-    return NULL;
+  bool isColorSpaceAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
+  std::string getColorSpaceAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isColorSpaceAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
+  }
+
+  SkPdfArray getColorSpaceAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
   long BitsPerComponent() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   std::string Intent() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Intent", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
-  SkPdfObject* ImageMask() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ImageMask", "", &ret)) return ret;
-    return NULL;
+  bool ImageMask() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ImageMask", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
-  SkPdfObject* Mask() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mask", "", &ret)) return ret;
-    return NULL;
+  bool isMaskAStream() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mask", "", &ret)) return false;
+    return ret->podofo()->HasStream();
   }
 
-  SkPdfObject* SMask() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream getMaskAsStream() const {
+    SkPdfStream ret = SkPdfStream();
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mask", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
-  SkPdfObject* Decode() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
-    return NULL;
+  bool isMaskAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mask", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfObject* Interpolate() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Interpolate", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray getMaskAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mask", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* Alternates() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternates", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream SMask() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
+  SkPdfArray Decode() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
+  bool Interpolate() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Interpolate", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
+  }
+
+  SkPdfArray Alternates() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternates", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
   std::string Name() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   long StructParent() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   std::string ID() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   SkPdfDictionary* OPI() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPI", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* Metadata() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream Metadata() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
 };
@@ -25797,17 +26537,18 @@
 
   SkPdfAlternateImageDictionary& operator=(const SkPdfAlternateImageDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* Image() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Image", "", &ret)) return ret;
+  SkPdfStream Image() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Image", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfStream();
   }
 
-  SkPdfObject* DefaultForPrinting() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DefaultForPrinting", "", &ret)) return ret;
-    return NULL;
+  bool DefaultForPrinting() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DefaultForPrinting", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
 };
@@ -25837,92 +26578,105 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string Subtype() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   long FormType() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FormType", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   std::string Name() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
-  SkPdfObject* LastModified() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
-    return NULL;
+  SkPdfDate LastModified() const {
+    SkPdfDate ret;
+    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfDate();
   }
 
-  SkPdfObject* BBox() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
+  SkRect BBox() const {
+    SkRect ret;
+    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkRect();
   }
 
-  SkPdfObject* Matrix() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Matrix() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   SkPdfDictionary* Resources() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Resources", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* Group() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Group", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* Ref() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ref", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* Metadata() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream Metadata() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
   SkPdfDictionary* PieceInfo() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PieceInfo", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   long StructParent() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long StructParents() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   SkPdfDictionary* OPI() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPI", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -26448,14 +27202,15 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string S() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
 };
@@ -26977,26 +27732,46 @@
 
   SkPdfReferenceDictionary& operator=(const SkPdfReferenceDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* F() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  SkPdfFileSpec F() const {
+    SkPdfFileSpec ret;
+    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfFileSpec();
   }
 
-  SkPdfObject* Page() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", &ret)) return ret;
+  bool isPageAInteger() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Number;
+  }
+
+  long getPageAsInteger() const {
+    long ret = 0;
+    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
-  SkPdfObject* ID() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
-    return NULL;
+  bool isPageAString() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
   }
 
+  std::string getPageAsString() const {
+    std::string ret = "";
+    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  SkPdfArray ID() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
 };
 
 
@@ -27519,20 +28294,22 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string Subtype() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* Level1() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Level1", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream Level1() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Level1", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
 };
@@ -27572,65 +28349,91 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Subtype() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Name() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string BaseFont() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   long FirstChar() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FirstChar", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long LastChar() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastChar", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* Widths() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Widths", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Widths() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Widths", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   SkPdfDictionary* FontDescriptor() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontDescriptor", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* Encoding() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
-    return NULL;
+  bool isEncodingAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  SkPdfObject* ToUnicode() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", &ret)) return ret;
+  std::string getEncodingAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isEncodingADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
+  }
+
+  SkPdfDictionary* getEncodingAsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
+  SkPdfStream ToUnicode() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
+  }
+
 };
 
 
@@ -27671,34 +28474,35 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Subtype() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Name() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
-  SkPdfObject* FontBBox() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontBBox", "", &ret)) return ret;
+  SkRect FontBBox() const {
+    SkRect ret;
+    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontBBox", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkRect();
   }
 
-  SkPdfObject* FontMatrix() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontMatrix", "", &ret)) return ret;
+  SkPdfArray FontMatrix() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontMatrix", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
 };
@@ -28223,19 +29027,22 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string BaseEncoding() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseEncoding", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
-  SkPdfObject* Differences() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Differences", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Differences() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Differences", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -28761,21 +29568,21 @@
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Registry", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Ordering() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ordering", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   long Supplement() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Supplement", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
 };
@@ -28818,21 +29625,21 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Subtype() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string BaseFont() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   SkPdfDictionary* CIDSystemInfo() const {
@@ -28845,39 +29652,64 @@
   SkPdfDictionary* FontDescriptor() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontDescriptor", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   long DW() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DW", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* W() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray W() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* DW2() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DW2", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray DW2() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DW2", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* W2() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W2", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray W2() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W2", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* CIDToGIDMap() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDToGIDMap", "", &ret)) return ret;
-    return NULL;
+  bool isCIDToGIDMapAStream() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDToGIDMap", "", &ret)) return false;
+    return ret->podofo()->HasStream();
   }
 
+  SkPdfStream getCIDToGIDMapAsStream() const {
+    SkPdfStream ret = SkPdfStream();
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDToGIDMap", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
+  }
+
+  bool isCIDToGIDMapAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDToGIDMap", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getCIDToGIDMapAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDToGIDMap", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
 };
 
 
@@ -29401,35 +30233,75 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string CMapName() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CMapName", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* CIDSystemInfo() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", &ret)) return ret;
+  bool isCIDSystemInfoADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
+  }
+
+  SkPdfDictionary* getCIDSystemInfoAsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
+  bool isCIDSystemInfoAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
+  }
+
+  SkPdfArray getCIDSystemInfoAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
   long WMode() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WMode", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* UseCMap() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UseCMap", "", &ret)) return ret;
-    return NULL;
+  bool isUseCMapAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UseCMap", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
+  std::string getUseCMapAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UseCMap", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isUseCMapAStream() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UseCMap", "", &ret)) return false;
+    return ret->podofo()->HasStream();
+  }
+
+  SkPdfStream getUseCMapAsStream() const {
+    SkPdfStream ret = SkPdfStream();
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UseCMap", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
+  }
+
 };
 
 
@@ -29470,43 +30342,63 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Subtype() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string BaseFont() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* Encoding() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
+  bool isEncodingAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getEncodingAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* DescendantFonts() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DescendantFonts", "", &ret)) return ret;
+  bool isEncodingAStream() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return false;
+    return ret->podofo()->HasStream();
+  }
+
+  SkPdfStream getEncodingAsStream() const {
+    SkPdfStream ret = SkPdfStream();
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfStream();
   }
 
-  SkPdfObject* ToUnicode() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray DescendantFonts() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DescendantFonts", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
+  SkPdfStream ToUnicode() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
+  }
+
 };
 
 
@@ -30030,54 +30922,55 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string FontName() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontName", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   long Flags() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
-  SkPdfObject* FontBBox() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontBBox", "", &ret)) return ret;
+  SkRect FontBBox() const {
+    SkRect ret;
+    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontBBox", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkRect();
   }
 
   double ItalicAngle() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ItalicAngle", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   double Ascent() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ascent", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   double Descent() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Descent", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   double Leading() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Leading", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -30085,12 +30978,13 @@
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CapHeight", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   double XHeight() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "XHeight", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -30098,54 +30992,62 @@
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StemV", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   double StemH() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StemH", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   double AvgWidth() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AvgWidth", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   double MaxWidth() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MaxWidth", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   double MissingWidth() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MissingWidth", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* FontFile() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream FontFile() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
-  SkPdfObject* FontFile2() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile2", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream FontFile2() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile2", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
-  SkPdfObject* FontFile3() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile3", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream FontFile3() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile3", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
   std::string CharSet() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CharSet", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
@@ -30671,25 +31573,29 @@
   SkPdfDictionary* Style() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Style", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   std::string Lang() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   SkPdfDictionary* FD() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FD", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* CIDSet() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSet", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream CIDSet() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSet", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
 };
@@ -31214,31 +32120,36 @@
   long Length1() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length1", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long Length2() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length2", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long Length3() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length3", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   std::string Subtype() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
-  SkPdfObject* Metadata() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream Metadata() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
 };
@@ -31763,19 +32674,21 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   long HalftoneType() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   std::string HalftoneName() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
@@ -31783,35 +32696,75 @@
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Frequency", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   double Angle() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Angle", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
-  SkPdfObject* SpotFunction() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpotFunction", "", &ret)) return ret;
+  bool isSpotFunctionAFunction() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpotFunction", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
+  }
+
+  SkPdfFunction getSpotFunctionAsFunction() const {
+    SkPdfFunction ret = SkPdfFunction();
+    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpotFunction", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfFunction();
   }
 
-  SkPdfObject* AccurateScreens() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AccurateScreens", "", &ret)) return ret;
-    return NULL;
+  bool isSpotFunctionAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpotFunction", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  SkPdfObject* TransferFunction() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
-    return NULL;
+  std::string getSpotFunctionAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpotFunction", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
+  bool AccurateScreens() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AccurateScreens", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
+  }
+
+  bool isTransferFunctionAFunction() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
+  }
+
+  SkPdfFunction getTransferFunctionAsFunction() const {
+    SkPdfFunction ret = SkPdfFunction();
+    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfFunction();
+  }
+
+  bool isTransferFunctionAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getTransferFunctionAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
 };
 
 
@@ -32334,19 +33287,21 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   long HalftoneType() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   std::string HalftoneName() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
@@ -32354,22 +33309,42 @@
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   long Height() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
-  SkPdfObject* TransferFunction() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
-    return NULL;
+  bool isTransferFunctionAFunction() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
+  SkPdfFunction getTransferFunctionAsFunction() const {
+    SkPdfFunction ret = SkPdfFunction();
+    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfFunction();
+  }
+
+  bool isTransferFunctionAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getTransferFunctionAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
 };
 
 
@@ -32892,19 +33867,21 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   long HalftoneType() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   std::string HalftoneName() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
@@ -32912,22 +33889,42 @@
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Xsquare", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   long Ysquare() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ysquare", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
-  SkPdfObject* TransferFunction() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
-    return NULL;
+  bool isTransferFunctionAFunction() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
+  SkPdfFunction getTransferFunctionAsFunction() const {
+    SkPdfFunction ret = SkPdfFunction();
+    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfFunction();
+  }
+
+  bool isTransferFunctionAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getTransferFunctionAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
 };
 
 
@@ -33450,19 +34447,21 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   long HalftoneType() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   std::string HalftoneName() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
@@ -33470,34 +34469,56 @@
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   long Height() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   long Width2() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width2", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long Height2() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height2", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* TransferFunction() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
-    return NULL;
+  bool isTransferFunctionAFunction() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
+  SkPdfFunction getTransferFunctionAsFunction() const {
+    SkPdfFunction ret = SkPdfFunction();
+    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfFunction();
+  }
+
+  bool isTransferFunctionAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getTransferFunctionAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
 };
 
 
@@ -34020,37 +35041,81 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   double HalftoneType() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   std::string HalftoneName() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
 /*
-  SkPdfObject* [any_colorant_name]() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_colorant_name]", "", &ret)) return ret;
+  bool has_[any_colorant_name]() const {
+    return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_colorant_name]", "", NULL));
+  }
+  bool is[any_colorant_name]ADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_colorant_name]", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
+  }
+
+  SkPdfDictionary* get[any_colorant_name]AsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_colorant_name]", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
+  bool is[any_colorant_name]AStream() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_colorant_name]", "", &ret)) return false;
+    return ret->podofo()->HasStream();
+  }
+
+  SkPdfStream get[any_colorant_name]AsStream() const {
+    SkPdfStream ret = SkPdfStream();
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_colorant_name]", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
+  }
+
 */
-  SkPdfObject* Default() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Default", "", &ret)) return ret;
+  bool isDefaultADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Default", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
+  }
+
+  SkPdfDictionary* getDefaultAsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Default", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
+  bool isDefaultAStream() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Default", "", &ret)) return false;
+    return ret->podofo()->HasStream();
+  }
+
+  SkPdfStream getDefaultAsStream() const {
+    SkPdfStream ret = SkPdfStream();
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Default", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
+  }
+
 };
 
 
@@ -34573,35 +35638,57 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string S() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* G() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "G", "", &ret)) return ret;
+  SkPdfStream G() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "G", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfStream();
   }
 
-  SkPdfObject* BC() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BC", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray BC() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BC", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* TR() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
-    return NULL;
+  bool isTRAFunction() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
+  SkPdfFunction getTRAsFunction() const {
+    SkPdfFunction ret = SkPdfFunction();
+    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfFunction();
+  }
+
+  bool isTRAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getTRAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
 };
 
 
@@ -35121,10 +36208,11 @@
 
   SkPdfSoftMaskImageDictionary& operator=(const SkPdfSoftMaskImageDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* Matte() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matte", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Matte() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matte", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -35650,15 +36738,35 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* CS() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CS", "", &ret)) return ret;
-    return NULL;
+  bool isCSAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CS", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
+  std::string getCSAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CS", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isCSAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CS", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
+  }
+
+  SkPdfArray getCSAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CS", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
 };
 
 
@@ -36178,76 +37286,88 @@
 
   SkPdfViewerPreferencesDictionary& operator=(const SkPdfViewerPreferencesDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* HideToolbar() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideToolbar", "", &ret)) return ret;
-    return NULL;
+  bool HideToolbar() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideToolbar", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
-  SkPdfObject* HideMenubar() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideMenubar", "", &ret)) return ret;
-    return NULL;
+  bool HideMenubar() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideMenubar", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
-  SkPdfObject* HideWindowUI() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideWindowUI", "", &ret)) return ret;
-    return NULL;
+  bool HideWindowUI() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideWindowUI", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
-  SkPdfObject* FitWindow() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FitWindow", "", &ret)) return ret;
-    return NULL;
+  bool FitWindow() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FitWindow", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
-  SkPdfObject* CenterWindow() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CenterWindow", "", &ret)) return ret;
-    return NULL;
+  bool CenterWindow() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CenterWindow", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
-  SkPdfObject* DisplayDocTitle() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DisplayDocTitle", "", &ret)) return ret;
-    return NULL;
+  bool DisplayDocTitle() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DisplayDocTitle", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
   std::string NonFullScreenPageMode() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NonFullScreenPageMode", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string Direction() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Direction", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string ViewArea() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewArea", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string ViewClip() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewClip", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string PrintArea() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PrintArea", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string PrintClip() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PrintClip", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
 };
@@ -36772,24 +37892,28 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   SkPdfDictionary* First() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "First", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* Last() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Last", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   long Count() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -37316,72 +38440,115 @@
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Title", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   SkPdfDictionary* Parent() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* Prev() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Prev", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* Next() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* First() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "First", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* Last() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Last", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   long Count() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* Dest() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
-    return NULL;
+  bool isDestAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
+  std::string getDestAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isDestAString() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
+  }
+
+  std::string getDestAsString() const {
+    std::string ret = "";
+    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isDestAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
+  }
+
+  SkPdfArray getDestAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
   SkPdfDictionary* A() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* SE() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SE", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* C() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray C() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   long F() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -37907,24 +39074,28 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string S() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string P() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   long St() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "St", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -38450,18 +39621,21 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   SkPdfDictionary* F() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* I() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -38987,38 +40161,43 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   SkPdfDictionary* T() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* N() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* V() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* P() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* R() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+  SkRect R() const {
+    SkRect ret;
+    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkRect();
   }
 
 };
@@ -39543,36 +40722,42 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   double D() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   std::string S() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string Dm() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dm", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string M() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   double Di() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Di", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -40098,116 +41283,145 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string Subtype() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Contents() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   SkPdfDictionary* P() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* Rect() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rect", "", &ret)) return ret;
+  SkRect Rect() const {
+    SkRect ret;
+    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rect", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkRect();
   }
 
-  SkPdfObject* NM() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NM", "", &ret)) return ret;
-    return NULL;
+  bool isMADate() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfObject* M() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
-    return NULL;
+  SkPdfDate getMAsDate() const {
+    SkPdfDate ret = SkPdfDate();
+    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfDate();
   }
 
+  bool isMAString() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
+  }
+
+  std::string getMAsString() const {
+    std::string ret = "";
+    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
   long F() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   SkPdfDictionary* BS() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* Border() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Border", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Border() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Border", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   SkPdfDictionary* AP() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   std::string AS() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AS", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
-  SkPdfObject* C() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray C() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   double CA() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   std::string T() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   SkPdfDictionary* Popup() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Popup", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* A() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* AA() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   long StructParent() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -40733,25 +41947,29 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   double W() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   std::string S() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
-  SkPdfObject* D() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray D() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -41273,22 +42491,81 @@
 
   SkPdfAppearanceDictionary& operator=(const SkPdfAppearanceDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* N() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
+  bool isNAStream() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return false;
+    return ret->podofo()->HasStream();
+  }
+
+  SkPdfStream getNAsStream() const {
+    SkPdfStream ret = SkPdfStream();
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
+  }
+
+  bool isNADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
+  }
+
+  SkPdfDictionary* getNAsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* R() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+  bool isRAStream() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return false;
+    return ret->podofo()->HasStream();
+  }
+
+  SkPdfStream getRAsStream() const {
+    SkPdfStream ret = SkPdfStream();
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
+  }
+
+  bool isRADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
+  }
+
+  SkPdfDictionary* getRAsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* D() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  bool isDAStream() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
+    return ret->podofo()->HasStream();
+  }
+
+  SkPdfStream getDAsStream() const {
+    SkPdfStream ret = SkPdfStream();
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
+  }
+
+  bool isDADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
+  }
+
+  SkPdfDictionary* getDAsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -41815,26 +43092,28 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Contents() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* Open() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Open", "", &ret)) return ret;
-    return NULL;
+  bool Open() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Open", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
   std::string Name() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
 };
@@ -42360,30 +43639,66 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Contents() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
-  SkPdfObject* Dest() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
-    return NULL;
+  bool isDestAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
+  SkPdfArray getDestAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
+  bool isDestAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getDestAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isDestAString() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
+  }
+
+  std::string getDestAsString() const {
+    std::string ret = "";
+    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
   std::string H() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   SkPdfDictionary* PA() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PA", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -42910,26 +44225,27 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Contents() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string DA() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   long Q() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -43456,39 +44772,42 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Contents() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* L() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "L", "", &ret)) return ret;
+  SkPdfArray L() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "L", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
   SkPdfDictionary* BS() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* LE() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LE", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray LE() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LE", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* IC() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IC", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray IC() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IC", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -44014,26 +45333,28 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Contents() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   SkPdfDictionary* BS() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* IC() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IC", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray IC() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IC", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -44559,21 +45880,21 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Contents() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* QuadPoints() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "QuadPoints", "", &ret)) return ret;
+  SkPdfArray QuadPoints() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "QuadPoints", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
 };
@@ -45099,20 +46420,21 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Contents() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Name() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
 };
@@ -45638,26 +46960,27 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Contents() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* InkList() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "InkList", "", &ret)) return ret;
+  SkPdfArray InkList() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "InkList", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
   SkPdfDictionary* BS() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -46184,25 +47507,28 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Contents() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   SkPdfDictionary* Parent() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* Open() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Open", "", &ret)) return ret;
-    return NULL;
+  bool Open() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Open", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
 };
@@ -46728,27 +48054,28 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* FS() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FS", "", &ret)) return ret;
+  SkPdfFileSpec FS() const {
+    SkPdfFileSpec ret;
+    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FS", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfFileSpec();
   }
 
   std::string Contents() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Name() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
 };
@@ -47274,26 +48601,28 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* Sound() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Sound", "", &ret)) return ret;
+  SkPdfStream Sound() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Sound", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfStream();
   }
 
   std::string Contents() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string Name() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
 };
@@ -47819,7 +49148,7 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   SkPdfDictionary* Movie() const {
@@ -47832,12 +49161,33 @@
   std::string Contents() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
-  SkPdfObject* A() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+  bool isAABoolean() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Bool;
+  }
+
+  bool getAAsBoolean() const {
+    bool ret = false;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
+  }
+
+  bool isAADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
+  }
+
+  SkPdfDictionary* getAAsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -48364,24 +49714,27 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Contents() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string H() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   SkPdfDictionary* MK() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MK", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -48907,22 +50260,43 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string S() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* Next() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", &ret)) return ret;
+  bool isNextADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
+  }
+
+  SkPdfDictionary* getNextAsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
+  bool isNextAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
+  }
+
+  SkPdfArray getNextAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
 };
 
 
@@ -49445,36 +50819,42 @@
   SkPdfDictionary* E() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* X() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "X", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* D() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* U() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* Fo() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fo", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* Bl() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Bl", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -50000,12 +51380,14 @@
   SkPdfDictionary* O() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* C() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -50531,24 +51913,28 @@
   SkPdfDictionary* K() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* F() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* V() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* C() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -51074,30 +52460,35 @@
   SkPdfDictionary* DC() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DC", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* WS() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WS", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* DS() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DS", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* WP() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WP", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* DP() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DP", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -51624,16 +53015,48 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* D() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  bool isDAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getDAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
+  bool isDAString() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
+  }
+
+  std::string getDAsString() const {
+    std::string ret = "";
+    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isDAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
+  }
+
+  SkPdfArray getDAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
 };
 
 
@@ -52157,29 +53580,62 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* F() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  SkPdfFileSpec F() const {
+    SkPdfFileSpec ret;
+    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfFileSpec();
   }
 
-  SkPdfObject* D() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  bool isDAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getDAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* NewWindow() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NewWindow", "", &ret)) return ret;
-    return NULL;
+  bool isDAString() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
   }
 
+  std::string getDAsString() const {
+    std::string ret = "";
+    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isDAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
+  }
+
+  SkPdfArray getDAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
+  bool NewWindow() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NewWindow", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
+  }
+
 };
 
 
@@ -52703,37 +54159,42 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* F() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    return NULL;
+  SkPdfFileSpec F() const {
+    SkPdfFileSpec ret;
+    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfFileSpec();
   }
 
   SkPdfDictionary* Win() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Win", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfObject* Mac() const {
     SkPdfObject* ret;
     if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfObject* Unix() const {
     SkPdfObject* ret;
     if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Unix", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* NewWindow() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NewWindow", "", &ret)) return ret;
-    return NULL;
+  bool NewWindow() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NewWindow", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
 };
@@ -53259,24 +54720,27 @@
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string D() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string O() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string P() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
@@ -53803,28 +55267,81 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* F() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    return NULL;
+  SkPdfFileSpec F() const {
+    SkPdfFileSpec ret;
+    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfFileSpec();
   }
 
-  SkPdfObject* D() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  bool isDADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
+  }
+
+  SkPdfDictionary* getDAsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* B() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
+  bool isDAInteger() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Number;
+  }
+
+  long getDAsInteger() const {
+    long ret = 0;
+    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return 0;
+  }
+
+  bool isDAString() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
+  }
+
+  std::string getDAsString() const {
+    std::string ret = "";
+    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isBADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
+  }
+
+  SkPdfDictionary* getBAsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
+  bool isBAInteger() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Number;
+  }
+
+  long getBAsInteger() const {
+    long ret = 0;
+    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return 0;
+  }
+
 };
 
 
@@ -54348,20 +55865,21 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string URI() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URI", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* IsMap() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IsMap", "", &ret)) return ret;
-    return NULL;
+  bool IsMap() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IsMap", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
 };
@@ -54886,6 +56404,7 @@
   std::string Base() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Base", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
@@ -55412,38 +56931,42 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* Sound() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Sound", "", &ret)) return ret;
+  SkPdfStream Sound() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Sound", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfStream();
   }
 
   double Volume() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Volume", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* Synchronous() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Synchronous", "", &ret)) return ret;
-    return NULL;
+  bool Synchronous() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Synchronous", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
-  SkPdfObject* Repeat() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Repeat", "", &ret)) return ret;
-    return NULL;
+  bool Repeat() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Repeat", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
-  SkPdfObject* Mix() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mix", "", &ret)) return ret;
-    return NULL;
+  bool Mix() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mix", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
 };
@@ -55969,25 +57492,28 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   SkPdfDictionary* Annot() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annot", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   std::string T() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string Operation() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Operation", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
 };
@@ -56513,22 +58039,55 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* T() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+  bool isTADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
+  }
+
+  SkPdfDictionary* getTAsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* H() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
-    return NULL;
+  bool isTAString() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
   }
 
+  std::string getTAsString() const {
+    std::string ret = "";
+    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isTAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
+  }
+
+  SkPdfArray getTAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
+  bool H() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
+  }
+
 };
 
 
@@ -57052,14 +58611,14 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string N() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
 };
@@ -57581,46 +59140,52 @@
 
   SkPdfInteractiveFormDictionary& operator=(const SkPdfInteractiveFormDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* Fields() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
+  SkPdfArray Fields() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
-  SkPdfObject* NeedAppearances() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NeedAppearances", "", &ret)) return ret;
-    return NULL;
+  bool NeedAppearances() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NeedAppearances", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
   long SigFlags() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SigFlags", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* CO() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CO", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray CO() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CO", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   SkPdfDictionary* DR() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DR", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   std::string DA() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   long Q() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -58146,60 +59711,70 @@
   std::string FT() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FT", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   SkPdfDictionary* Parent() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* Kids() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Kids() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   std::string T() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string TU() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TU", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string TM() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TM", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   long Ff() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ff", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   SkPdfObject* V() const {
     SkPdfObject* ret;
     if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfObject* DV() const {
     SkPdfObject* ret;
     if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DV", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* AA() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -58733,12 +60308,13 @@
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   long Q() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -59264,66 +60840,77 @@
   long R() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* BC() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BC", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray BC() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BC", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* BG() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray BG() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   std::string CA() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string RC() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RC", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string AC() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AC", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
-  SkPdfObject* I() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream I() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
-  SkPdfObject* RI() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RI", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream RI() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RI", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
-  SkPdfObject* IX() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IX", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream IX() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IX", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
   SkPdfDictionary* IF() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IF", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   long TP() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TP", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -59849,6 +61436,7 @@
   std::string Opt() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
@@ -60371,10 +61959,11 @@
 
   SkPdfRadioButtonFieldDictionary& operator=(const SkPdfRadioButtonFieldDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* Opt() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Opt() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -60899,6 +62488,7 @@
   long MaxLen() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MaxLen", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -61421,23 +63011,25 @@
 
   SkPdfChoiceFieldDictionary& operator=(const SkPdfChoiceFieldDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* Opt() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
+  SkPdfArray Opt() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
   long TI() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TI", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* I() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray I() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -61962,57 +63554,63 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string Filter() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string SubFilter() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SubFilter", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
-  SkPdfObject* ByteRange() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ByteRange", "", &ret)) return ret;
+  SkPdfArray ByteRange() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ByteRange", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
   std::string Contents() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Name() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
-  SkPdfObject* M() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
-    return NULL;
+  SkPdfDate M() const {
+    SkPdfDate ret;
+    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfDate();
   }
 
   std::string Location() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Location", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string Reason() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Reason", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
@@ -62539,25 +64137,27 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* F() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  SkPdfFileSpec F() const {
+    SkPdfFileSpec ret;
+    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfFileSpec();
   }
 
-  SkPdfObject* Fields() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Fields() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   long Flags() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -63084,18 +64684,20 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* Fields() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Fields() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   long Flags() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -63622,14 +65224,14 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* F() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  SkPdfFileSpec F() const {
+    SkPdfFileSpec ret;
+    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfFileSpec();
   }
 
 };
@@ -64155,16 +65757,35 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* JS() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JS", "", &ret)) return ret;
+  bool isJSAString() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JS", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
+  }
+
+  std::string getJSAsString() const {
+    std::string ret = "";
+    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JS", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
+  bool isJSAStream() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JS", "", &ret)) return false;
+    return ret->podofo()->HasStream();
+  }
+
+  SkPdfStream getJSAsStream() const {
+    SkPdfStream ret = SkPdfStream();
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JS", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
+  }
+
 };
 
 
@@ -64687,6 +66308,7 @@
   SkPdfDictionary* Root() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Root", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -65212,7 +66834,8 @@
   std::string Version() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   SkPdfDictionary* FDF() const {
@@ -65741,69 +67364,80 @@
 
   SkPdfFDFDictionary& operator=(const SkPdfFDFDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* F() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    return NULL;
+  SkPdfFileSpec F() const {
+    SkPdfFileSpec ret;
+    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfFileSpec();
   }
 
-  SkPdfObject* ID() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray ID() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* Fields() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Fields() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   std::string Status() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Status", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
-  SkPdfObject* Pages() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Pages() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   std::string Encoding() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
-  SkPdfObject* Annots() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annots", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Annots() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annots", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* Differences() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Differences", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream Differences() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Differences", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
   std::string Target() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Target", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
-  SkPdfObject* EmbeddedFDFs() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFDFs", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray EmbeddedFDFs() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFDFs", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   SkPdfDictionary* JavaScript() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -66329,6 +67963,7 @@
   long EncryptionRevision() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EncryptionRevision", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -66851,24 +68486,65 @@
 
   SkPdfJavascriptDictionary& operator=(const SkPdfJavascriptDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* Before() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Before", "", &ret)) return ret;
-    return NULL;
+  bool isBeforeAString() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Before", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
   }
 
-  SkPdfObject* After() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "After", "", &ret)) return ret;
-    return NULL;
+  std::string getBeforeAsString() const {
+    std::string ret = "";
+    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Before", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
-  SkPdfObject* Doc() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Doc", "", &ret)) return ret;
-    return NULL;
+  bool isBeforeAStream() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Before", "", &ret)) return false;
+    return ret->podofo()->HasStream();
   }
 
+  SkPdfStream getBeforeAsStream() const {
+    SkPdfStream ret = SkPdfStream();
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Before", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
+  }
+
+  bool isAfterAString() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "After", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
+  }
+
+  std::string getAfterAsString() const {
+    std::string ret = "";
+    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "After", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isAfterAStream() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "After", "", &ret)) return false;
+    return ret->podofo()->HasStream();
+  }
+
+  SkPdfStream getAfterAsStream() const {
+    SkPdfStream ret = SkPdfStream();
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "After", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
+  }
+
+  SkPdfArray Doc() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Doc", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
 };
 
 
@@ -67388,94 +69064,108 @@
 
   SkPdfFDFFieldDictionary& operator=(const SkPdfFDFFieldDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* Kids() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Kids() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   std::string T() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   SkPdfObject* V() const {
     SkPdfObject* ret;
     if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   long Ff() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ff", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long SetFf() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SetFf", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long ClrFf() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClrFf", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long F() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long SetF() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SetF", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long ClrF() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClrF", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   SkPdfDictionary* AP() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* APRef() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "APRef", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* IF() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IF", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* Opt() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Opt() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   SkPdfDictionary* A() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* AA() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -68002,21 +69692,21 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SW", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string S() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* A() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+  SkPdfArray A() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
 };
@@ -68538,16 +70228,17 @@
 
   SkPdfFDFPageDictionary& operator=(const SkPdfFDFPageDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* Templates() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return ret;
+  SkPdfArray Templates() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
   SkPdfDictionary* Info() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -69077,16 +70768,18 @@
     return NULL;
   }
 
-  SkPdfObject* Fields() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Fields() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* Rename() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rename", "", &ret)) return ret;
-    return NULL;
+  bool Rename() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rename", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
 };
@@ -69612,13 +71305,14 @@
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* F() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    return NULL;
+  SkPdfFileSpec F() const {
+    SkPdfFileSpec ret;
+    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfFileSpec();
   }
 
 };
@@ -70143,6 +71837,7 @@
   long Page() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -70668,43 +72363,49 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   double R() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
   long C() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long B() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   std::string E() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string CO() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CO", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   SkPdfObject* CP() const {
     SkPdfObject* ret;
     if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CP", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -71227,31 +72928,53 @@
 
   SkPdfMovieDictionary& operator=(const SkPdfMovieDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* F() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  SkPdfFileSpec F() const {
+    SkPdfFileSpec ret;
+    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfFileSpec();
   }
 
-  SkPdfObject* Aspect() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Aspect", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Aspect() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Aspect", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   long Rotate() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rotate", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* Poster() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Poster", "", &ret)) return ret;
-    return NULL;
+  bool isPosterABoolean() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Poster", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Bool;
   }
 
+  bool getPosterAsBoolean() const {
+    bool ret = false;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Poster", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
+  }
+
+  bool isPosterAStream() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Poster", "", &ret)) return false;
+    return ret->podofo()->HasStream();
+  }
+
+  SkPdfStream getPosterAsStream() const {
+    SkPdfStream ret = SkPdfStream();
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Poster", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
+  }
+
 };
 
 
@@ -71774,55 +73497,64 @@
   SkPdfObject* Start() const {
     SkPdfObject* ret;
     if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Start", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfObject* Duration() const {
     SkPdfObject* ret;
     if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Duration", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   double Rate() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rate", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   double Volume() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Volume", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* ShowControls() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ShowControls", "", &ret)) return ret;
-    return NULL;
+  bool ShowControls() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ShowControls", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
   std::string Mode() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mode", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
-  SkPdfObject* Synchronous() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Synchronous", "", &ret)) return ret;
-    return NULL;
+  bool Synchronous() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Synchronous", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
-  SkPdfObject* FWScale() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FWScale", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray FWScale() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FWScale", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* FWPosition() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FWPosition", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray FWPosition() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FWPosition", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -72347,55 +74079,64 @@
   std::string Title() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Title", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string Author() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Author", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string Subject() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subject", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string Keywords() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Keywords", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string Creator() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Creator", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string Producer() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Producer", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
-  SkPdfObject* CreationDate() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CreationDate", "", &ret)) return ret;
-    return NULL;
+  SkPdfDate CreationDate() const {
+    SkPdfDate ret;
+    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CreationDate", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfDate();
   }
 
-  SkPdfObject* ModDate() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ModDate", "", &ret)) return ret;
-    return NULL;
+  SkPdfDate ModDate() const {
+    SkPdfDate ret;
+    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ModDate", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfDate();
   }
 
   std::string Trapped() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Trapped", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
 };
@@ -72921,14 +74662,14 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Subtype() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
 };
@@ -73450,10 +75191,11 @@
 
   SkPdfComponentsWithMetadataDictionary& operator=(const SkPdfComponentsWithMetadataDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* Metadata() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream Metadata() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
 };
@@ -73976,9 +75718,13 @@
   SkPdfPagePieceDictionary& operator=(const SkPdfPagePieceDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
 /*
+  bool has_[any_application_name_or_well_known_data_type]() const {
+    return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_application_name_or_well_known_data_type]", "", NULL));
+  }
   SkPdfDictionary* [any_application_name_or_well_known_data_type]() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_application_name_or_well_known_data_type]", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -74502,16 +76248,17 @@
 
   SkPdfApplicationDataDictionary& operator=(const SkPdfApplicationDataDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* LastModified() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
+  SkPdfDate LastModified() const {
+    SkPdfDate ret;
+    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfDate();
   }
 
   SkPdfObject* Private() const {
     SkPdfObject* ret;
     if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Private", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -75038,42 +76785,105 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* K() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
+  bool isKADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
+  }
+
+  SkPdfDictionary* getKAsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* IDTree() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDTree", "", &ret)) return ret;
+  bool isKAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
+  }
+
+  SkPdfArray getKAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
+  bool isIDTreeAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDTree", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getIDTreeAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDTree", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isIDTreeATree() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDTree", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
+  }
+
+  SkPdfTree* getIDTreeAsTree() const {
+    SkPdfTree* ret = NULL;
+    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDTree", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* ParentTree() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTree", "", &ret)) return ret;
+  bool isParentTreeANumber() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTree", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Real;
+  }
+
+  double getParentTreeAsNumber() const {
+    double ret = 0;
+    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTree", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return 0;
+  }
+
+  bool isParentTreeATree() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTree", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Reference;
+  }
+
+  SkPdfTree* getParentTreeAsTree() const {
+    SkPdfTree* ret = NULL;
+    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTree", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   long ParentTreeNextKey() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTreeNextKey", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   SkPdfDictionary* RoleMap() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RoleMap", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* ClassMap() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClassMap", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -75599,79 +77409,110 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string S() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   SkPdfDictionary* P() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   std::string ID() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   SkPdfDictionary* Pg() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfObject* K() const {
     SkPdfObject* ret;
     if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfObject* A() const {
     SkPdfObject* ret;
     if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* C() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
-    return NULL;
+  bool isCAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
+  std::string getCAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isCAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
+  }
+
+  SkPdfArray getCAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
   long R() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   std::string T() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string Lang() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string Alt() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alt", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string ActualText() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ActualText", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
@@ -76198,24 +78039,27 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   SkPdfDictionary* Pg() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
-  SkPdfObject* Stm() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Stm", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream Stm() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Stm", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
   SkPdfObject* StmOwn() const {
     SkPdfObject* ret;
     if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StmOwn", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -76223,7 +78067,7 @@
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MCID", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
 };
@@ -76749,18 +78593,20 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   SkPdfDictionary* Pg() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfObject* Obj() const {
     SkPdfObject* ret;
     if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Obj", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -77286,12 +79132,14 @@
   long StructParent() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long StructParents() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -77818,7 +79666,7 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
 };
@@ -78340,10 +80188,11 @@
 
   SkPdfMarkInformationDictionary& operator=(const SkPdfMarkInformationDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* Marked() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Marked", "", &ret)) return ret;
-    return NULL;
+  bool Marked() const {
+    bool ret;
+    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Marked", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return false;
   }
 
 };
@@ -78868,19 +80717,22 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
-  SkPdfObject* BBox() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
-    return NULL;
+  SkRect BBox() const {
+    SkRect ret;
+    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkRect();
   }
 
-  SkPdfObject* Attached() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Attached", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Attached() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Attached", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -79405,13 +81257,15 @@
   std::string Placement() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Placement", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string WritingMode() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WritingMode", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
 };
@@ -79936,67 +81790,116 @@
   double SpaceBefore() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpaceBefore", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   double SpaceAfter() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpaceAfter", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   double StartIndent() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StartIndent", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   double EndIndent() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndIndent", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   double TextIndent() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TextIndent", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   std::string TextAlign() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TextAlign", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
-  SkPdfObject* BBox() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
-    return NULL;
+  SkRect BBox() const {
+    SkRect ret;
+    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkRect();
   }
 
-  SkPdfObject* Width() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
-    return NULL;
+  bool isWidthANumber() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Real;
   }
 
-  SkPdfObject* Height() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
-    return NULL;
+  double getWidthAsNumber() const {
+    double ret = 0;
+    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return 0;
   }
 
+  bool isWidthAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getWidthAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isHeightANumber() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Real;
+  }
+
+  double getHeightAsNumber() const {
+    double ret = 0;
+    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return 0;
+  }
+
+  bool isHeightAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getHeightAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
   std::string BlockAlign() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlockAlign", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string InlineAlign() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "InlineAlign", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
 };
@@ -80518,12 +82421,32 @@
 
   SkPdfInlineLevelStructureElementsDictionary& operator=(const SkPdfInlineLevelStructureElementsDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* LineHeight() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LineHeight", "", &ret)) return ret;
-    return NULL;
+  bool isLineHeightANumber() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LineHeight", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Real;
   }
 
+  double getLineHeightAsNumber() const {
+    double ret = 0;
+    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LineHeight", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return 0;
+  }
+
+  bool isLineHeightAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LineHeight", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getLineHeightAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LineHeight", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
 };
 
 
@@ -81046,7 +82969,8 @@
   std::string ListNumbering() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ListNumbering", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
 };
@@ -81571,12 +83495,14 @@
   long RowSpan() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RowSpan", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long ColSpan() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColSpan", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
@@ -82103,13 +84029,14 @@
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
-  SkPdfObject* C() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray C() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -82634,47 +84561,69 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string S() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string ID() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* O() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
+  SkPdfArray O() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
-  SkPdfObject* SI() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SI", "", &ret)) return ret;
+  bool isSIADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SI", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
+  }
+
+  SkPdfDictionary* getSIAsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SI", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
+  bool isSIAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SI", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
+  }
+
+  SkPdfArray getSIAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SI", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
   std::string CT() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CT", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
-  SkPdfObject* TS() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TS", "", &ret)) return ret;
-    return NULL;
+  SkPdfDate TS() const {
+    SkPdfDate ret;
+    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TS", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfDate();
   }
 
 };
@@ -83200,18 +85149,20 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string T() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string TID() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TID", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
@@ -83738,16 +85689,35 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* R() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+  bool isRAInteger() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Number;
+  }
+
+  long getRAsInteger() const {
+    long ret = 0;
+    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return 0;
   }
 
+  bool isRAArray() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Array;
+  }
+
+  SkPdfArray getRAsArray() const {
+    SkPdfArray ret = SkPdfArray();
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
 };
 
 
@@ -84267,34 +86237,57 @@
 
   SkPdfSourceInformationDictionary& operator=(const SkPdfSourceInformationDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* AU() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AU", "", &ret)) return ret;
+  bool isAUAString() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AU", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
+  }
+
+  std::string getAUAsString() const {
+    std::string ret = "";
+    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AU", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* TS() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TS", "", &ret)) return ret;
-    return NULL;
+  bool isAUADictionary() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AU", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfObject* E() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", &ret)) return ret;
+  SkPdfDictionary* getAUAsDictionary() const {
+    SkPdfDictionary* ret = NULL;
+    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AU", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
+  SkPdfDate TS() const {
+    SkPdfDate ret;
+    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TS", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfDate();
+  }
+
+  SkPdfDate E() const {
+    SkPdfDate ret;
+    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfDate();
+  }
+
   long S() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   SkPdfDictionary* C() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -84821,13 +86814,14 @@
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* C() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray C() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -85353,42 +87347,67 @@
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URL", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   long L() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "L", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   long F() const {
     long ret;
     if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
-  SkPdfObject* P() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
-    return NULL;
+  bool isPAString() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
   }
 
+  std::string getPAsString() const {
+    std::string ret = "";
+    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  bool isPAStream() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return false;
+    return ret->podofo()->HasStream();
+  }
+
+  SkPdfStream getPAsStream() const {
+    SkPdfStream ret = SkPdfStream();
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
+  }
+
   std::string CT() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CT", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string H() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   SkPdfDictionary* S() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -85914,12 +87933,14 @@
   SkPdfDictionary* G() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "G", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* C() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -86445,24 +88466,28 @@
   SkPdfDictionary* CropBox() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CropBox", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* BleedBox() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BleedBox", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* TrimBox() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrimBox", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
   SkPdfDictionary* ArtBox() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ArtBox", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -86985,29 +89010,32 @@
 
   SkPdfBoxStyleDictionary& operator=(const SkPdfBoxStyleDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* C() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+  SkPdfArray C() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
   double W() const {
     double ret;
     if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return 0;
   }
 
   std::string S() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
-  SkPdfObject* D() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray D() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -87533,13 +89561,14 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string MN() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MN", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
 };
@@ -88064,12 +90093,14 @@
   std::string MarkStyle() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MarkStyle", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   SkPdfDictionary* Colorants() const {
     SkPdfDictionary* ret;
     if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colorants", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return NULL;
   }
 
@@ -88592,26 +90623,46 @@
 
   SkPdfSeparationDictionary& operator=(const SkPdfSeparationDictionary& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}
 
-  SkPdfObject* Pages() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
+  SkPdfArray Pages() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return SkPdfArray();
   }
 
-  SkPdfObject* DeviceColorant() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DeviceColorant", "", &ret)) return ret;
+  bool isDeviceColorantAName() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DeviceColorant", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_Name;
+  }
+
+  std::string getDeviceColorantAsName() const {
+    std::string ret = "";
+    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DeviceColorant", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* ColorSpace() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
-    return NULL;
+  bool isDeviceColorantAString() const {
+    SkPdfObject* ret = NULL;
+    if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DeviceColorant", "", &ret)) return false;
+    return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
   }
 
+  std::string getDeviceColorantAsString() const {
+    std::string ret = "";
+    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DeviceColorant", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
+  }
+
+  SkPdfArray ColorSpace() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
+  }
+
 };
 
 
@@ -89134,19 +91185,21 @@
   std::string Type() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    return """";
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return "";
   }
 
   std::string S() const {
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string OutputCondition() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputCondition", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
@@ -89154,25 +91207,28 @@
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputConditionIdentifier", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string RegistryName() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RegistryName", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
   std::string Info() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
-  SkPdfObject* DestOutputProfile() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DestOutputProfile", "", &ret)) return ret;
-    return NULL;
+  SkPdfStream DestOutputProfile() const {
+    SkPdfStream ret;
+    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DestOutputProfile", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfStream();
   }
 
 };
@@ -89698,37 +91754,42 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
   std::string Contents() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
-  SkPdfObject* LastModified() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
-    return NULL;
+  SkPdfDate LastModified() const {
+    SkPdfDate ret;
+    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfDate();
   }
 
-  SkPdfObject* Version() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray Version() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* AnnotStates() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AnnotStates", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray AnnotStates() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AnnotStates", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* FontFauxing() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFauxing", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray FontFauxing() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFauxing", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
 };
@@ -90254,24 +92315,27 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PCM", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
-  SkPdfObject* SeparationColorNames() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SeparationColorNames", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray SeparationColorNames() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SeparationColorNames", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
-  SkPdfObject* TrapRegions() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrapRegions", "", &ret)) return ret;
-    return NULL;
+  SkPdfArray TrapRegions() const {
+    SkPdfArray ret;
+    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrapRegions", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
+    return SkPdfArray();
   }
 
   std::string TrapStyles() const {
     std::string ret;
     if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrapStyles", "", &ret)) return ret;
+    // TODO(edisonn): warn about missing required field, assert for known good pdfs
     return "";
   }
 
@@ -90826,7 +92890,7 @@
     std::string ret;
     if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
     // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
+    return "";
   }
 
 };
@@ -90839,7 +92903,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObject** out) {
-    if (!isAObject(podofoDoc, podofoObj)) return false;
+    if (!isObject(podofoDoc, podofoObj)) return false;
 
     if (map(podofoDoc, podofoObj, (SkPdfArray**)out)) return true;
     if (map(podofoDoc, podofoObj, (SkPdfBoolean**)out)) return true;
@@ -90861,7 +92925,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNull** out) {
-    if (!isANull(podofoDoc, podofoObj)) return false;
+    if (!isNull(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfNull(&podofoDoc, &podofoObj);
@@ -90873,7 +92937,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoolean** out) {
-    if (!isABoolean(podofoDoc, podofoObj)) return false;
+    if (!isBoolean(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfBoolean(&podofoDoc, &podofoObj);
@@ -90885,7 +92949,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInteger** out) {
-    if (!isAInteger(podofoDoc, podofoObj)) return false;
+    if (!isInteger(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfInteger(&podofoDoc, &podofoObj);
@@ -90897,7 +92961,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNumber** out) {
-    if (!isANumber(podofoDoc, podofoObj)) return false;
+    if (!isNumber(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfNumber(&podofoDoc, &podofoObj);
@@ -90909,7 +92973,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfName** out) {
-    if (!isAName(podofoDoc, podofoObj)) return false;
+    if (!isName(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfName(&podofoDoc, &podofoObj);
@@ -90921,7 +92985,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfReference** out) {
-    if (!isAReference(podofoDoc, podofoObj)) return false;
+    if (!isReference(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfReference(&podofoDoc, &podofoObj);
@@ -90933,7 +92997,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfArray** out) {
-    if (!isAArray(podofoDoc, podofoObj)) return false;
+    if (!isArray(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfArray(&podofoDoc, &podofoObj);
@@ -90945,7 +93009,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfString** out) {
-    if (!isAString(podofoDoc, podofoObj)) return false;
+    if (!isString(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfString(&podofoDoc, &podofoObj);
@@ -90957,7 +93021,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfHexString** out) {
-    if (!isAHexString(podofoDoc, podofoObj)) return false;
+    if (!isHexString(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfHexString(&podofoDoc, &podofoObj);
@@ -90969,7 +93033,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDictionary** out) {
-    if (!isADictionary(podofoDoc, podofoObj)) return false;
+    if (!isDictionary(podofoDoc, podofoObj)) return false;
 
     if (map(podofoDoc, podofoObj, (SkPdfALinkAnnotationDictionary**)out)) return true;
     if (map(podofoDoc, podofoObj, (SkPdfActionDictionary**)out)) return true;
@@ -91134,7 +93198,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfXObjectDictionary** out) {
-    if (!isAXObjectDictionary(podofoDoc, podofoObj)) return false;
+    if (!isXObjectDictionary(podofoDoc, podofoObj)) return false;
 
     if (map(podofoDoc, podofoObj, (SkPdfImageDictionary**)out)) return true;
     if (map(podofoDoc, podofoObj, (SkPdfType1FormDictionary**)out)) return true;
@@ -91148,7 +93212,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFontDictionary** out) {
-    if (!isAFontDictionary(podofoDoc, podofoObj)) return false;
+    if (!isFontDictionary(podofoDoc, podofoObj)) return false;
 
     if (map(podofoDoc, podofoObj, (SkPdfCIDFontDictionary**)out)) return true;
     if (map(podofoDoc, podofoObj, (SkPdfTrueTypeFontDictionary**)out)) return true;
@@ -91165,7 +93229,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrueTypeFontDictionary** out) {
-    if (!isATrueTypeFontDictionary(podofoDoc, podofoObj)) return false;
+    if (!isTrueTypeFontDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfTrueTypeFontDictionary(&podofoDoc, &podofoObj);
@@ -91177,7 +93241,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStreamCommonDictionary** out) {
-    if (!isAStreamCommonDictionary(podofoDoc, podofoObj)) return false;
+    if (!isStreamCommonDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfStreamCommonDictionary(&podofoDoc, &podofoObj);
@@ -91189,7 +93253,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** out) {
-    if (!isALzwdecodeAndFlatedecodeFiltersDictionary(podofoDoc, podofoObj)) return false;
+    if (!isLzwdecodeAndFlatedecodeFiltersDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfLzwdecodeAndFlatedecodeFiltersDictionary(&podofoDoc, &podofoObj);
@@ -91201,7 +93265,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCcittfaxdecodeFilterDictionary** out) {
-    if (!isACcittfaxdecodeFilterDictionary(podofoDoc, podofoObj)) return false;
+    if (!isCcittfaxdecodeFilterDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfCcittfaxdecodeFilterDictionary(&podofoDoc, &podofoObj);
@@ -91213,7 +93277,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJbig2DecodeFilterDictionary** out) {
-    if (!isAJbig2DecodeFilterDictionary(podofoDoc, podofoObj)) return false;
+    if (!isJbig2DecodeFilterDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfJbig2DecodeFilterDictionary(&podofoDoc, &podofoObj);
@@ -91225,7 +93289,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDctdecodeFilterDictionary** out) {
-    if (!isADctdecodeFilterDictionary(podofoDoc, podofoObj)) return false;
+    if (!isDctdecodeFilterDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfDctdecodeFilterDictionary(&podofoDoc, &podofoObj);
@@ -91237,7 +93301,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileTrailerDictionary** out) {
-    if (!isAFileTrailerDictionary(podofoDoc, podofoObj)) return false;
+    if (!isFileTrailerDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfFileTrailerDictionary(&podofoDoc, &podofoObj);
@@ -91249,7 +93313,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncryptionCommonDictionary** out) {
-    if (!isAEncryptionCommonDictionary(podofoDoc, podofoObj)) return false;
+    if (!isEncryptionCommonDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfEncryptionCommonDictionary(&podofoDoc, &podofoObj);
@@ -91261,7 +93325,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStandardSecurityHandlerDictionary** out) {
-    if (!isAStandardSecurityHandlerDictionary(podofoDoc, podofoObj)) return false;
+    if (!isStandardSecurityHandlerDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfStandardSecurityHandlerDictionary(&podofoDoc, &podofoObj);
@@ -91273,7 +93337,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCatalogDictionary** out) {
-    if (!isACatalogDictionary(podofoDoc, podofoObj)) return false;
+    if (!isCatalogDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfCatalogDictionary(&podofoDoc, &podofoObj);
@@ -91285,7 +93349,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageTreeNodeDictionary** out) {
-    if (!isAPageTreeNodeDictionary(podofoDoc, podofoObj)) return false;
+    if (!isPageTreeNodeDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfPageTreeNodeDictionary(&podofoDoc, &podofoObj);
@@ -91297,7 +93361,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageObjectDictionary** out) {
-    if (!isAPageObjectDictionary(podofoDoc, podofoObj)) return false;
+    if (!isPageObjectDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfPageObjectDictionary(&podofoDoc, &podofoObj);
@@ -91309,7 +93373,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNameDictionary** out) {
-    if (!isANameDictionary(podofoDoc, podofoObj)) return false;
+    if (!isNameDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfNameDictionary(&podofoDoc, &podofoObj);
@@ -91321,7 +93385,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfResourceDictionary** out) {
-    if (!isAResourceDictionary(podofoDoc, podofoObj)) return false;
+    if (!isResourceDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfResourceDictionary(&podofoDoc, &podofoObj);
@@ -91333,7 +93397,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNameTreeNodeDictionary** out) {
-    if (!isANameTreeNodeDictionary(podofoDoc, podofoObj)) return false;
+    if (!isNameTreeNodeDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfNameTreeNodeDictionary(&podofoDoc, &podofoObj);
@@ -91345,7 +93409,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNumberTreeNodeDictionary** out) {
-    if (!isANumberTreeNodeDictionary(podofoDoc, podofoObj)) return false;
+    if (!isNumberTreeNodeDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfNumberTreeNodeDictionary(&podofoDoc, &podofoObj);
@@ -91357,7 +93421,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFunctionCommonDictionary** out) {
-    if (!isAFunctionCommonDictionary(podofoDoc, podofoObj)) return false;
+    if (!isFunctionCommonDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfFunctionCommonDictionary(&podofoDoc, &podofoObj);
@@ -91369,7 +93433,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType0FunctionDictionary** out) {
-    if (!isAType0FunctionDictionary(podofoDoc, podofoObj)) return false;
+    if (!isType0FunctionDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfType0FunctionDictionary(&podofoDoc, &podofoObj);
@@ -91381,7 +93445,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2FunctionDictionary** out) {
-    if (!isAType2FunctionDictionary(podofoDoc, podofoObj)) return false;
+    if (!isType2FunctionDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfType2FunctionDictionary(&podofoDoc, &podofoObj);
@@ -91393,7 +93457,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3FunctionDictionary** out) {
-    if (!isAType3FunctionDictionary(podofoDoc, podofoObj)) return false;
+    if (!isType3FunctionDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfType3FunctionDictionary(&podofoDoc, &podofoObj);
@@ -91405,7 +93469,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileSpecificationDictionary** out) {
-    if (!isAFileSpecificationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isFileSpecificationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfFileSpecificationDictionary(&podofoDoc, &podofoObj);
@@ -91417,7 +93481,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFileStreamDictionary** out) {
-    if (!isAEmbeddedFileStreamDictionary(podofoDoc, podofoObj)) return false;
+    if (!isEmbeddedFileStreamDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfEmbeddedFileStreamDictionary(&podofoDoc, &podofoObj);
@@ -91429,7 +93493,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFileParameterDictionary** out) {
-    if (!isAEmbeddedFileParameterDictionary(podofoDoc, podofoObj)) return false;
+    if (!isEmbeddedFileParameterDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfEmbeddedFileParameterDictionary(&podofoDoc, &podofoObj);
@@ -91441,7 +93505,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMacOsFileInformationDictionary** out) {
-    if (!isAMacOsFileInformationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isMacOsFileInformationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfMacOsFileInformationDictionary(&podofoDoc, &podofoObj);
@@ -91453,7 +93517,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGraphicsStateDictionary** out) {
-    if (!isAGraphicsStateDictionary(podofoDoc, podofoObj)) return false;
+    if (!isGraphicsStateDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfGraphicsStateDictionary(&podofoDoc, &podofoObj);
@@ -91465,7 +93529,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCalgrayColorSpaceDictionary** out) {
-    if (!isACalgrayColorSpaceDictionary(podofoDoc, podofoObj)) return false;
+    if (!isCalgrayColorSpaceDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfCalgrayColorSpaceDictionary(&podofoDoc, &podofoObj);
@@ -91477,7 +93541,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCalrgbColorSpaceDictionary** out) {
-    if (!isACalrgbColorSpaceDictionary(podofoDoc, podofoObj)) return false;
+    if (!isCalrgbColorSpaceDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfCalrgbColorSpaceDictionary(&podofoDoc, &podofoObj);
@@ -91489,7 +93553,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLabColorSpaceDictionary** out) {
-    if (!isALabColorSpaceDictionary(podofoDoc, podofoObj)) return false;
+    if (!isLabColorSpaceDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfLabColorSpaceDictionary(&podofoDoc, &podofoObj);
@@ -91501,7 +93565,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfIccProfileStreamDictionary** out) {
-    if (!isAIccProfileStreamDictionary(podofoDoc, podofoObj)) return false;
+    if (!isIccProfileStreamDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfIccProfileStreamDictionary(&podofoDoc, &podofoObj);
@@ -91513,7 +93577,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDeviceNColorSpaceDictionary** out) {
-    if (!isADeviceNColorSpaceDictionary(podofoDoc, podofoObj)) return false;
+    if (!isDeviceNColorSpaceDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfDeviceNColorSpaceDictionary(&podofoDoc, &podofoObj);
@@ -91525,7 +93589,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1PatternDictionary** out) {
-    if (!isAType1PatternDictionary(podofoDoc, podofoObj)) return false;
+    if (!isType1PatternDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfType1PatternDictionary(&podofoDoc, &podofoObj);
@@ -91537,7 +93601,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2PatternDictionary** out) {
-    if (!isAType2PatternDictionary(podofoDoc, podofoObj)) return false;
+    if (!isType2PatternDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfType2PatternDictionary(&podofoDoc, &podofoObj);
@@ -91549,7 +93613,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfShadingDictionary** out) {
-    if (!isAShadingDictionary(podofoDoc, podofoObj)) return false;
+    if (!isShadingDictionary(podofoDoc, podofoObj)) return false;
 
     if (map(podofoDoc, podofoObj, (SkPdfType1ShadingDictionary**)out)) return true;
     if (map(podofoDoc, podofoObj, (SkPdfType2ShadingDictionary**)out)) return true;
@@ -91567,7 +93631,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1ShadingDictionary** out) {
-    if (!isAType1ShadingDictionary(podofoDoc, podofoObj)) return false;
+    if (!isType1ShadingDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfType1ShadingDictionary(&podofoDoc, &podofoObj);
@@ -91579,7 +93643,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2ShadingDictionary** out) {
-    if (!isAType2ShadingDictionary(podofoDoc, podofoObj)) return false;
+    if (!isType2ShadingDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfType2ShadingDictionary(&podofoDoc, &podofoObj);
@@ -91591,7 +93655,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3ShadingDictionary** out) {
-    if (!isAType3ShadingDictionary(podofoDoc, podofoObj)) return false;
+    if (!isType3ShadingDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfType3ShadingDictionary(&podofoDoc, &podofoObj);
@@ -91603,7 +93667,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType4ShadingDictionary** out) {
-    if (!isAType4ShadingDictionary(podofoDoc, podofoObj)) return false;
+    if (!isType4ShadingDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfType4ShadingDictionary(&podofoDoc, &podofoObj);
@@ -91615,7 +93679,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType5ShadingDictionary** out) {
-    if (!isAType5ShadingDictionary(podofoDoc, podofoObj)) return false;
+    if (!isType5ShadingDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfType5ShadingDictionary(&podofoDoc, &podofoObj);
@@ -91627,7 +93691,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType6ShadingDictionary** out) {
-    if (!isAType6ShadingDictionary(podofoDoc, podofoObj)) return false;
+    if (!isType6ShadingDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfType6ShadingDictionary(&podofoDoc, &podofoObj);
@@ -91639,7 +93703,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfImageDictionary** out) {
-    if (!isAImageDictionary(podofoDoc, podofoObj)) return false;
+    if (!isImageDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfImageDictionary(&podofoDoc, &podofoObj);
@@ -91651,7 +93715,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAlternateImageDictionary** out) {
-    if (!isAAlternateImageDictionary(podofoDoc, podofoObj)) return false;
+    if (!isAlternateImageDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfAlternateImageDictionary(&podofoDoc, &podofoObj);
@@ -91663,7 +93727,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1FormDictionary** out) {
-    if (!isAType1FormDictionary(podofoDoc, podofoObj)) return false;
+    if (!isType1FormDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfType1FormDictionary(&podofoDoc, &podofoObj);
@@ -91675,7 +93739,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGroupAttributesDictionary** out) {
-    if (!isAGroupAttributesDictionary(podofoDoc, podofoObj)) return false;
+    if (!isGroupAttributesDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfGroupAttributesDictionary(&podofoDoc, &podofoObj);
@@ -91687,7 +93751,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfReferenceDictionary** out) {
-    if (!isAReferenceDictionary(podofoDoc, podofoObj)) return false;
+    if (!isReferenceDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfReferenceDictionary(&podofoDoc, &podofoObj);
@@ -91699,7 +93763,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPSXobjectDictionary** out) {
-    if (!isAPSXobjectDictionary(podofoDoc, podofoObj)) return false;
+    if (!isPSXobjectDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfPSXobjectDictionary(&podofoDoc, &podofoObj);
@@ -91711,7 +93775,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1FontDictionary** out) {
-    if (!isAType1FontDictionary(podofoDoc, podofoObj)) return false;
+    if (!isType1FontDictionary(podofoDoc, podofoObj)) return false;
 
     if (map(podofoDoc, podofoObj, (SkPdfMultiMasterFontDictionary**)out)) return true;
 
@@ -91724,7 +93788,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3FontDictionary** out) {
-    if (!isAType3FontDictionary(podofoDoc, podofoObj)) return false;
+    if (!isType3FontDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfType3FontDictionary(&podofoDoc, &podofoObj);
@@ -91736,7 +93800,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncodingDictionary** out) {
-    if (!isAEncodingDictionary(podofoDoc, podofoObj)) return false;
+    if (!isEncodingDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfEncodingDictionary(&podofoDoc, &podofoObj);
@@ -91748,7 +93812,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDSystemInfoDictionary** out) {
-    if (!isACIDSystemInfoDictionary(podofoDoc, podofoObj)) return false;
+    if (!isCIDSystemInfoDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfCIDSystemInfoDictionary(&podofoDoc, &podofoObj);
@@ -91760,7 +93824,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDFontDictionary** out) {
-    if (!isACIDFontDictionary(podofoDoc, podofoObj)) return false;
+    if (!isCIDFontDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfCIDFontDictionary(&podofoDoc, &podofoObj);
@@ -91772,7 +93836,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCMapDictionary** out) {
-    if (!isACMapDictionary(podofoDoc, podofoObj)) return false;
+    if (!isCMapDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfCMapDictionary(&podofoDoc, &podofoObj);
@@ -91784,7 +93848,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType0FontDictionary** out) {
-    if (!isAType0FontDictionary(podofoDoc, podofoObj)) return false;
+    if (!isType0FontDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfType0FontDictionary(&podofoDoc, &podofoObj);
@@ -91796,7 +93860,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFontDescriptorDictionary** out) {
-    if (!isAFontDescriptorDictionary(podofoDoc, podofoObj)) return false;
+    if (!isFontDescriptorDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfFontDescriptorDictionary(&podofoDoc, &podofoObj);
@@ -91808,7 +93872,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDFontDescriptorDictionary** out) {
-    if (!isACIDFontDescriptorDictionary(podofoDoc, podofoObj)) return false;
+    if (!isCIDFontDescriptorDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfCIDFontDescriptorDictionary(&podofoDoc, &podofoObj);
@@ -91820,7 +93884,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFontStreamDictionary** out) {
-    if (!isAEmbeddedFontStreamDictionary(podofoDoc, podofoObj)) return false;
+    if (!isEmbeddedFontStreamDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfEmbeddedFontStreamDictionary(&podofoDoc, &podofoObj);
@@ -91832,7 +93896,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1HalftoneDictionary** out) {
-    if (!isAType1HalftoneDictionary(podofoDoc, podofoObj)) return false;
+    if (!isType1HalftoneDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfType1HalftoneDictionary(&podofoDoc, &podofoObj);
@@ -91844,7 +93908,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType6HalftoneDictionary** out) {
-    if (!isAType6HalftoneDictionary(podofoDoc, podofoObj)) return false;
+    if (!isType6HalftoneDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfType6HalftoneDictionary(&podofoDoc, &podofoObj);
@@ -91856,7 +93920,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType10HalftoneDictionary** out) {
-    if (!isAType10HalftoneDictionary(podofoDoc, podofoObj)) return false;
+    if (!isType10HalftoneDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfType10HalftoneDictionary(&podofoDoc, &podofoObj);
@@ -91868,7 +93932,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType16HalftoneDictionary** out) {
-    if (!isAType16HalftoneDictionary(podofoDoc, podofoObj)) return false;
+    if (!isType16HalftoneDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfType16HalftoneDictionary(&podofoDoc, &podofoObj);
@@ -91880,7 +93944,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType5HalftoneDictionary** out) {
-    if (!isAType5HalftoneDictionary(podofoDoc, podofoObj)) return false;
+    if (!isType5HalftoneDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfType5HalftoneDictionary(&podofoDoc, &podofoObj);
@@ -91892,7 +93956,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoftMaskDictionary** out) {
-    if (!isASoftMaskDictionary(podofoDoc, podofoObj)) return false;
+    if (!isSoftMaskDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfSoftMaskDictionary(&podofoDoc, &podofoObj);
@@ -91904,7 +93968,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoftMaskImageDictionary** out) {
-    if (!isASoftMaskImageDictionary(podofoDoc, podofoObj)) return false;
+    if (!isSoftMaskImageDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfSoftMaskImageDictionary(&podofoDoc, &podofoObj);
@@ -91916,7 +93980,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTransparencyGroupDictionary** out) {
-    if (!isATransparencyGroupDictionary(podofoDoc, podofoObj)) return false;
+    if (!isTransparencyGroupDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfTransparencyGroupDictionary(&podofoDoc, &podofoObj);
@@ -91928,7 +93992,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfViewerPreferencesDictionary** out) {
-    if (!isAViewerPreferencesDictionary(podofoDoc, podofoObj)) return false;
+    if (!isViewerPreferencesDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfViewerPreferencesDictionary(&podofoDoc, &podofoObj);
@@ -91940,7 +94004,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOutlineDictionary** out) {
-    if (!isAOutlineDictionary(podofoDoc, podofoObj)) return false;
+    if (!isOutlineDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfOutlineDictionary(&podofoDoc, &podofoObj);
@@ -91952,7 +94016,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOutlineItemDictionary** out) {
-    if (!isAOutlineItemDictionary(podofoDoc, podofoObj)) return false;
+    if (!isOutlineItemDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfOutlineItemDictionary(&podofoDoc, &podofoObj);
@@ -91964,7 +94028,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageLabelDictionary** out) {
-    if (!isAPageLabelDictionary(podofoDoc, podofoObj)) return false;
+    if (!isPageLabelDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfPageLabelDictionary(&podofoDoc, &podofoObj);
@@ -91976,7 +94040,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfThreadDictionary** out) {
-    if (!isAThreadDictionary(podofoDoc, podofoObj)) return false;
+    if (!isThreadDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfThreadDictionary(&podofoDoc, &podofoObj);
@@ -91988,7 +94052,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBeadDictionary** out) {
-    if (!isABeadDictionary(podofoDoc, podofoObj)) return false;
+    if (!isBeadDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfBeadDictionary(&podofoDoc, &podofoObj);
@@ -92000,7 +94064,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTransitionDictionary** out) {
-    if (!isATransitionDictionary(podofoDoc, podofoObj)) return false;
+    if (!isTransitionDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfTransitionDictionary(&podofoDoc, &podofoObj);
@@ -92012,7 +94076,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAnnotationDictionary** out) {
-    if (!isAAnnotationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isAnnotationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfAnnotationDictionary(&podofoDoc, &podofoObj);
@@ -92024,7 +94088,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBorderStyleDictionary** out) {
-    if (!isABorderStyleDictionary(podofoDoc, podofoObj)) return false;
+    if (!isBorderStyleDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfBorderStyleDictionary(&podofoDoc, &podofoObj);
@@ -92036,7 +94100,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAppearanceDictionary** out) {
-    if (!isAAppearanceDictionary(podofoDoc, podofoObj)) return false;
+    if (!isAppearanceDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfAppearanceDictionary(&podofoDoc, &podofoObj);
@@ -92048,7 +94112,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTextAnnotationDictionary** out) {
-    if (!isATextAnnotationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isTextAnnotationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfTextAnnotationDictionary(&podofoDoc, &podofoObj);
@@ -92060,7 +94124,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfALinkAnnotationDictionary** out) {
-    if (!isAALinkAnnotationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isALinkAnnotationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfALinkAnnotationDictionary(&podofoDoc, &podofoObj);
@@ -92072,7 +94136,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFreeTextAnnotationDictionary** out) {
-    if (!isAFreeTextAnnotationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isFreeTextAnnotationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfFreeTextAnnotationDictionary(&podofoDoc, &podofoObj);
@@ -92084,7 +94148,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLineAnnotationDictionary** out) {
-    if (!isALineAnnotationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isLineAnnotationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfLineAnnotationDictionary(&podofoDoc, &podofoObj);
@@ -92096,7 +94160,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSquareOrCircleAnnotation** out) {
-    if (!isASquareOrCircleAnnotation(podofoDoc, podofoObj)) return false;
+    if (!isSquareOrCircleAnnotation(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfSquareOrCircleAnnotation(&podofoDoc, &podofoObj);
@@ -92108,7 +94172,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkupAnnotationsDictionary** out) {
-    if (!isAMarkupAnnotationsDictionary(podofoDoc, podofoObj)) return false;
+    if (!isMarkupAnnotationsDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfMarkupAnnotationsDictionary(&podofoDoc, &podofoObj);
@@ -92120,7 +94184,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRubberStampAnnotationDictionary** out) {
-    if (!isARubberStampAnnotationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isRubberStampAnnotationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfRubberStampAnnotationDictionary(&podofoDoc, &podofoObj);
@@ -92132,7 +94196,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInkAnnotationDictionary** out) {
-    if (!isAInkAnnotationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isInkAnnotationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfInkAnnotationDictionary(&podofoDoc, &podofoObj);
@@ -92144,7 +94208,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPopUpAnnotationDictionary** out) {
-    if (!isAPopUpAnnotationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isPopUpAnnotationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfPopUpAnnotationDictionary(&podofoDoc, &podofoObj);
@@ -92156,7 +94220,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileAttachmentAnnotationDictionary** out) {
-    if (!isAFileAttachmentAnnotationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isFileAttachmentAnnotationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfFileAttachmentAnnotationDictionary(&podofoDoc, &podofoObj);
@@ -92168,7 +94232,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundAnnotationDictionary** out) {
-    if (!isASoundAnnotationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isSoundAnnotationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfSoundAnnotationDictionary(&podofoDoc, &podofoObj);
@@ -92180,7 +94244,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieAnnotationDictionary** out) {
-    if (!isAMovieAnnotationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isMovieAnnotationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfMovieAnnotationDictionary(&podofoDoc, &podofoObj);
@@ -92192,7 +94256,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWidgetAnnotationDictionary** out) {
-    if (!isAWidgetAnnotationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isWidgetAnnotationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfWidgetAnnotationDictionary(&podofoDoc, &podofoObj);
@@ -92204,7 +94268,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfActionDictionary** out) {
-    if (!isAActionDictionary(podofoDoc, podofoObj)) return false;
+    if (!isActionDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfActionDictionary(&podofoDoc, &podofoObj);
@@ -92216,7 +94280,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAnnotationActionsDictionary** out) {
-    if (!isAAnnotationActionsDictionary(podofoDoc, podofoObj)) return false;
+    if (!isAnnotationActionsDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfAnnotationActionsDictionary(&podofoDoc, &podofoObj);
@@ -92228,7 +94292,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageObjectActionsDictionary** out) {
-    if (!isAPageObjectActionsDictionary(podofoDoc, podofoObj)) return false;
+    if (!isPageObjectActionsDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfPageObjectActionsDictionary(&podofoDoc, &podofoObj);
@@ -92240,7 +94304,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFormFieldActionsDictionary** out) {
-    if (!isAFormFieldActionsDictionary(podofoDoc, podofoObj)) return false;
+    if (!isFormFieldActionsDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfFormFieldActionsDictionary(&podofoDoc, &podofoObj);
@@ -92252,7 +94316,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDocumentCatalogActionsDictionary** out) {
-    if (!isADocumentCatalogActionsDictionary(podofoDoc, podofoObj)) return false;
+    if (!isDocumentCatalogActionsDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfDocumentCatalogActionsDictionary(&podofoDoc, &podofoObj);
@@ -92264,7 +94328,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGoToActionDictionary** out) {
-    if (!isAGoToActionDictionary(podofoDoc, podofoObj)) return false;
+    if (!isGoToActionDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfGoToActionDictionary(&podofoDoc, &podofoObj);
@@ -92276,7 +94340,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRemoteGoToActionDictionary** out) {
-    if (!isARemoteGoToActionDictionary(podofoDoc, podofoObj)) return false;
+    if (!isRemoteGoToActionDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfRemoteGoToActionDictionary(&podofoDoc, &podofoObj);
@@ -92288,7 +94352,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLaunchActionDictionary** out) {
-    if (!isALaunchActionDictionary(podofoDoc, podofoObj)) return false;
+    if (!isLaunchActionDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfLaunchActionDictionary(&podofoDoc, &podofoObj);
@@ -92300,7 +94364,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWindowsLaunchActionDictionary** out) {
-    if (!isAWindowsLaunchActionDictionary(podofoDoc, podofoObj)) return false;
+    if (!isWindowsLaunchActionDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfWindowsLaunchActionDictionary(&podofoDoc, &podofoObj);
@@ -92312,7 +94376,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfThreadActionDictionary** out) {
-    if (!isAThreadActionDictionary(podofoDoc, podofoObj)) return false;
+    if (!isThreadActionDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfThreadActionDictionary(&podofoDoc, &podofoObj);
@@ -92324,7 +94388,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURIActionDictionary** out) {
-    if (!isAURIActionDictionary(podofoDoc, podofoObj)) return false;
+    if (!isURIActionDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfURIActionDictionary(&podofoDoc, &podofoObj);
@@ -92336,7 +94400,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURIDictionary** out) {
-    if (!isAURIDictionary(podofoDoc, podofoObj)) return false;
+    if (!isURIDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfURIDictionary(&podofoDoc, &podofoObj);
@@ -92348,7 +94412,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundActionDictionary** out) {
-    if (!isASoundActionDictionary(podofoDoc, podofoObj)) return false;
+    if (!isSoundActionDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfSoundActionDictionary(&podofoDoc, &podofoObj);
@@ -92360,7 +94424,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieActionDictionary** out) {
-    if (!isAMovieActionDictionary(podofoDoc, podofoObj)) return false;
+    if (!isMovieActionDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfMovieActionDictionary(&podofoDoc, &podofoObj);
@@ -92372,7 +94436,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfHideActionDictionary** out) {
-    if (!isAHideActionDictionary(podofoDoc, podofoObj)) return false;
+    if (!isHideActionDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfHideActionDictionary(&podofoDoc, &podofoObj);
@@ -92384,7 +94448,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNamedActionsDictionary** out) {
-    if (!isANamedActionsDictionary(podofoDoc, podofoObj)) return false;
+    if (!isNamedActionsDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfNamedActionsDictionary(&podofoDoc, &podofoObj);
@@ -92396,7 +94460,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInteractiveFormDictionary** out) {
-    if (!isAInteractiveFormDictionary(podofoDoc, podofoObj)) return false;
+    if (!isInteractiveFormDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfInteractiveFormDictionary(&podofoDoc, &podofoObj);
@@ -92408,7 +94472,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFieldDictionary** out) {
-    if (!isAFieldDictionary(podofoDoc, podofoObj)) return false;
+    if (!isFieldDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfFieldDictionary(&podofoDoc, &podofoObj);
@@ -92420,7 +94484,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfVariableTextFieldDictionary** out) {
-    if (!isAVariableTextFieldDictionary(podofoDoc, podofoObj)) return false;
+    if (!isVariableTextFieldDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfVariableTextFieldDictionary(&podofoDoc, &podofoObj);
@@ -92432,7 +94496,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAppearanceCharacteristicsDictionary** out) {
-    if (!isAAppearanceCharacteristicsDictionary(podofoDoc, podofoObj)) return false;
+    if (!isAppearanceCharacteristicsDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfAppearanceCharacteristicsDictionary(&podofoDoc, &podofoObj);
@@ -92444,7 +94508,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCheckboxFieldDictionary** out) {
-    if (!isACheckboxFieldDictionary(podofoDoc, podofoObj)) return false;
+    if (!isCheckboxFieldDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfCheckboxFieldDictionary(&podofoDoc, &podofoObj);
@@ -92456,7 +94520,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRadioButtonFieldDictionary** out) {
-    if (!isARadioButtonFieldDictionary(podofoDoc, podofoObj)) return false;
+    if (!isRadioButtonFieldDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfRadioButtonFieldDictionary(&podofoDoc, &podofoObj);
@@ -92468,7 +94532,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTextFieldDictionary** out) {
-    if (!isATextFieldDictionary(podofoDoc, podofoObj)) return false;
+    if (!isTextFieldDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfTextFieldDictionary(&podofoDoc, &podofoObj);
@@ -92480,7 +94544,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfChoiceFieldDictionary** out) {
-    if (!isAChoiceFieldDictionary(podofoDoc, podofoObj)) return false;
+    if (!isChoiceFieldDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfChoiceFieldDictionary(&podofoDoc, &podofoObj);
@@ -92492,7 +94556,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSignatureDictionary** out) {
-    if (!isASignatureDictionary(podofoDoc, podofoObj)) return false;
+    if (!isSignatureDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfSignatureDictionary(&podofoDoc, &podofoObj);
@@ -92504,7 +94568,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSubmitFormActionDictionary** out) {
-    if (!isASubmitFormActionDictionary(podofoDoc, podofoObj)) return false;
+    if (!isSubmitFormActionDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfSubmitFormActionDictionary(&podofoDoc, &podofoObj);
@@ -92516,7 +94580,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfResetFormActionDictionary** out) {
-    if (!isAResetFormActionDictionary(podofoDoc, podofoObj)) return false;
+    if (!isResetFormActionDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfResetFormActionDictionary(&podofoDoc, &podofoObj);
@@ -92528,7 +94592,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfImportDataActionDictionary** out) {
-    if (!isAImportDataActionDictionary(podofoDoc, podofoObj)) return false;
+    if (!isImportDataActionDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfImportDataActionDictionary(&podofoDoc, &podofoObj);
@@ -92540,7 +94604,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJavascriptActionDictionary** out) {
-    if (!isAJavascriptActionDictionary(podofoDoc, podofoObj)) return false;
+    if (!isJavascriptActionDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfJavascriptActionDictionary(&podofoDoc, &podofoObj);
@@ -92552,7 +94616,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFTrailerDictionary** out) {
-    if (!isAFDFTrailerDictionary(podofoDoc, podofoObj)) return false;
+    if (!isFDFTrailerDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfFDFTrailerDictionary(&podofoDoc, &podofoObj);
@@ -92564,7 +94628,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFCatalogDictionary** out) {
-    if (!isAFDFCatalogDictionary(podofoDoc, podofoObj)) return false;
+    if (!isFDFCatalogDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfFDFCatalogDictionary(&podofoDoc, &podofoObj);
@@ -92576,7 +94640,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFDictionary** out) {
-    if (!isAFDFDictionary(podofoDoc, podofoObj)) return false;
+    if (!isFDFDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfFDFDictionary(&podofoDoc, &podofoObj);
@@ -92588,7 +94652,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncryptedEmbeddedFileStreamDictionary** out) {
-    if (!isAEncryptedEmbeddedFileStreamDictionary(podofoDoc, podofoObj)) return false;
+    if (!isEncryptedEmbeddedFileStreamDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfEncryptedEmbeddedFileStreamDictionary(&podofoDoc, &podofoObj);
@@ -92600,7 +94664,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJavascriptDictionary** out) {
-    if (!isAJavascriptDictionary(podofoDoc, podofoObj)) return false;
+    if (!isJavascriptDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfJavascriptDictionary(&podofoDoc, &podofoObj);
@@ -92612,7 +94676,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFFieldDictionary** out) {
-    if (!isAFDFFieldDictionary(podofoDoc, podofoObj)) return false;
+    if (!isFDFFieldDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfFDFFieldDictionary(&podofoDoc, &podofoObj);
@@ -92624,7 +94688,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfIconFitDictionary** out) {
-    if (!isAIconFitDictionary(podofoDoc, podofoObj)) return false;
+    if (!isIconFitDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfIconFitDictionary(&podofoDoc, &podofoObj);
@@ -92636,7 +94700,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFPageDictionary** out) {
-    if (!isAFDFPageDictionary(podofoDoc, podofoObj)) return false;
+    if (!isFDFPageDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfFDFPageDictionary(&podofoDoc, &podofoObj);
@@ -92648,7 +94712,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFTemplateDictionary** out) {
-    if (!isAFDFTemplateDictionary(podofoDoc, podofoObj)) return false;
+    if (!isFDFTemplateDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfFDFTemplateDictionary(&podofoDoc, &podofoObj);
@@ -92660,7 +94724,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFNamedPageReferenceDictionary** out) {
-    if (!isAFDFNamedPageReferenceDictionary(podofoDoc, podofoObj)) return false;
+    if (!isFDFNamedPageReferenceDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfFDFNamedPageReferenceDictionary(&podofoDoc, &podofoObj);
@@ -92672,7 +94736,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFFileAnnotationDictionary** out) {
-    if (!isAFDFFileAnnotationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isFDFFileAnnotationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfFDFFileAnnotationDictionary(&podofoDoc, &podofoObj);
@@ -92684,7 +94748,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundObjectDictionary** out) {
-    if (!isASoundObjectDictionary(podofoDoc, podofoObj)) return false;
+    if (!isSoundObjectDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfSoundObjectDictionary(&podofoDoc, &podofoObj);
@@ -92696,7 +94760,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieDictionary** out) {
-    if (!isAMovieDictionary(podofoDoc, podofoObj)) return false;
+    if (!isMovieDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfMovieDictionary(&podofoDoc, &podofoObj);
@@ -92708,7 +94772,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieActivationDictionary** out) {
-    if (!isAMovieActivationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isMovieActivationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfMovieActivationDictionary(&podofoDoc, &podofoObj);
@@ -92720,7 +94784,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDocumentInformationDictionary** out) {
-    if (!isADocumentInformationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isDocumentInformationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfDocumentInformationDictionary(&podofoDoc, &podofoObj);
@@ -92732,7 +94796,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMetadataStreamDictionary** out) {
-    if (!isAMetadataStreamDictionary(podofoDoc, podofoObj)) return false;
+    if (!isMetadataStreamDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfMetadataStreamDictionary(&podofoDoc, &podofoObj);
@@ -92744,7 +94808,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfComponentsWithMetadataDictionary** out) {
-    if (!isAComponentsWithMetadataDictionary(podofoDoc, podofoObj)) return false;
+    if (!isComponentsWithMetadataDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfComponentsWithMetadataDictionary(&podofoDoc, &podofoObj);
@@ -92756,7 +94820,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPagePieceDictionary** out) {
-    if (!isAPagePieceDictionary(podofoDoc, podofoObj)) return false;
+    if (!isPagePieceDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfPagePieceDictionary(&podofoDoc, &podofoObj);
@@ -92768,7 +94832,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfApplicationDataDictionary** out) {
-    if (!isAApplicationDataDictionary(podofoDoc, podofoObj)) return false;
+    if (!isApplicationDataDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfApplicationDataDictionary(&podofoDoc, &podofoObj);
@@ -92780,7 +94844,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureTreeRootDictionary** out) {
-    if (!isAStructureTreeRootDictionary(podofoDoc, podofoObj)) return false;
+    if (!isStructureTreeRootDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfStructureTreeRootDictionary(&podofoDoc, &podofoObj);
@@ -92792,7 +94856,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureElementDictionary** out) {
-    if (!isAStructureElementDictionary(podofoDoc, podofoObj)) return false;
+    if (!isStructureElementDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfStructureElementDictionary(&podofoDoc, &podofoObj);
@@ -92804,7 +94868,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkedContentReferenceDictionary** out) {
-    if (!isAMarkedContentReferenceDictionary(podofoDoc, podofoObj)) return false;
+    if (!isMarkedContentReferenceDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfMarkedContentReferenceDictionary(&podofoDoc, &podofoObj);
@@ -92816,7 +94880,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObjectReferenceDictionary** out) {
-    if (!isAObjectReferenceDictionary(podofoDoc, podofoObj)) return false;
+    if (!isObjectReferenceDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfObjectReferenceDictionary(&podofoDoc, &podofoObj);
@@ -92828,7 +94892,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureElementAccessDictionary** out) {
-    if (!isAStructureElementAccessDictionary(podofoDoc, podofoObj)) return false;
+    if (!isStructureElementAccessDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfStructureElementAccessDictionary(&podofoDoc, &podofoObj);
@@ -92840,7 +94904,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAttributeObjectDictionary** out) {
-    if (!isAAttributeObjectDictionary(podofoDoc, podofoObj)) return false;
+    if (!isAttributeObjectDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfAttributeObjectDictionary(&podofoDoc, &podofoObj);
@@ -92852,7 +94916,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkInformationDictionary** out) {
-    if (!isAMarkInformationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isMarkInformationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfMarkInformationDictionary(&podofoDoc, &podofoObj);
@@ -92864,7 +94928,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfArtifactsDictionary** out) {
-    if (!isAArtifactsDictionary(podofoDoc, podofoObj)) return false;
+    if (!isArtifactsDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfArtifactsDictionary(&podofoDoc, &podofoObj);
@@ -92876,7 +94940,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStandardStructureDictionary** out) {
-    if (!isAStandardStructureDictionary(podofoDoc, podofoObj)) return false;
+    if (!isStandardStructureDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfStandardStructureDictionary(&podofoDoc, &podofoObj);
@@ -92888,7 +94952,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBlockLevelStructureElementsDictionary** out) {
-    if (!isABlockLevelStructureElementsDictionary(podofoDoc, podofoObj)) return false;
+    if (!isBlockLevelStructureElementsDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfBlockLevelStructureElementsDictionary(&podofoDoc, &podofoObj);
@@ -92900,7 +94964,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInlineLevelStructureElementsDictionary** out) {
-    if (!isAInlineLevelStructureElementsDictionary(podofoDoc, podofoObj)) return false;
+    if (!isInlineLevelStructureElementsDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfInlineLevelStructureElementsDictionary(&podofoDoc, &podofoObj);
@@ -92912,7 +94976,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfListAttributeDictionary** out) {
-    if (!isAListAttributeDictionary(podofoDoc, podofoObj)) return false;
+    if (!isListAttributeDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfListAttributeDictionary(&podofoDoc, &podofoObj);
@@ -92924,7 +94988,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTableAttributesDictionary** out) {
-    if (!isATableAttributesDictionary(podofoDoc, podofoObj)) return false;
+    if (!isTableAttributesDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfTableAttributesDictionary(&podofoDoc, &podofoObj);
@@ -92936,7 +95000,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureInformationDictionary** out) {
-    if (!isAWebCaptureInformationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isWebCaptureInformationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfWebCaptureInformationDictionary(&podofoDoc, &podofoObj);
@@ -92948,7 +95012,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureDictionary** out) {
-    if (!isAWebCaptureDictionary(podofoDoc, podofoObj)) return false;
+    if (!isWebCaptureDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfWebCaptureDictionary(&podofoDoc, &podofoObj);
@@ -92960,7 +95024,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCapturePageSetDictionary** out) {
-    if (!isAWebCapturePageSetDictionary(podofoDoc, podofoObj)) return false;
+    if (!isWebCapturePageSetDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfWebCapturePageSetDictionary(&podofoDoc, &podofoObj);
@@ -92972,7 +95036,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureImageSetDictionary** out) {
-    if (!isAWebCaptureImageSetDictionary(podofoDoc, podofoObj)) return false;
+    if (!isWebCaptureImageSetDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfWebCaptureImageSetDictionary(&podofoDoc, &podofoObj);
@@ -92984,7 +95048,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSourceInformationDictionary** out) {
-    if (!isASourceInformationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isSourceInformationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfSourceInformationDictionary(&podofoDoc, &podofoObj);
@@ -92996,7 +95060,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURLAliasDictionary** out) {
-    if (!isAURLAliasDictionary(podofoDoc, podofoObj)) return false;
+    if (!isURLAliasDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfURLAliasDictionary(&podofoDoc, &podofoObj);
@@ -93008,7 +95072,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureCommandDictionary** out) {
-    if (!isAWebCaptureCommandDictionary(podofoDoc, podofoObj)) return false;
+    if (!isWebCaptureCommandDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfWebCaptureCommandDictionary(&podofoDoc, &podofoObj);
@@ -93020,7 +95084,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureCommandSettingsDictionary** out) {
-    if (!isAWebCaptureCommandSettingsDictionary(podofoDoc, podofoObj)) return false;
+    if (!isWebCaptureCommandSettingsDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfWebCaptureCommandSettingsDictionary(&podofoDoc, &podofoObj);
@@ -93032,7 +95096,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoxColorInformationDictionary** out) {
-    if (!isABoxColorInformationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isBoxColorInformationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfBoxColorInformationDictionary(&podofoDoc, &podofoObj);
@@ -93044,7 +95108,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoxStyleDictionary** out) {
-    if (!isABoxStyleDictionary(podofoDoc, podofoObj)) return false;
+    if (!isBoxStyleDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfBoxStyleDictionary(&podofoDoc, &podofoObj);
@@ -93056,7 +95120,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPrinterMarkAnnotationDictionary** out) {
-    if (!isAPrinterMarkAnnotationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isPrinterMarkAnnotationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfPrinterMarkAnnotationDictionary(&podofoDoc, &podofoObj);
@@ -93068,7 +95132,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPrinterMarkFormDictionary** out) {
-    if (!isAPrinterMarkFormDictionary(podofoDoc, podofoObj)) return false;
+    if (!isPrinterMarkFormDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfPrinterMarkFormDictionary(&podofoDoc, &podofoObj);
@@ -93080,7 +95144,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSeparationDictionary** out) {
-    if (!isASeparationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isSeparationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfSeparationDictionary(&podofoDoc, &podofoObj);
@@ -93092,7 +95156,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPDF_XOutputIntentDictionary** out) {
-    if (!isAPDF_XOutputIntentDictionary(podofoDoc, podofoObj)) return false;
+    if (!isPDF_XOutputIntentDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfPDF_XOutputIntentDictionary(&podofoDoc, &podofoObj);
@@ -93104,7 +95168,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrapNetworkAnnotationDictionary** out) {
-    if (!isATrapNetworkAnnotationDictionary(podofoDoc, podofoObj)) return false;
+    if (!isTrapNetworkAnnotationDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfTrapNetworkAnnotationDictionary(&podofoDoc, &podofoObj);
@@ -93116,7 +95180,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrapNetworkAppearanceStreamDictionary** out) {
-    if (!isATrapNetworkAppearanceStreamDictionary(podofoDoc, podofoObj)) return false;
+    if (!isTrapNetworkAppearanceStreamDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfTrapNetworkAppearanceStreamDictionary(&podofoDoc, &podofoObj);
@@ -93128,7 +95192,7 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOpiVersionDictionary** out) {
-    if (!isAOpiVersionDictionary(podofoDoc, podofoObj)) return false;
+    if (!isOpiVersionDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfOpiVersionDictionary(&podofoDoc, &podofoObj);
@@ -93140,222 +95204,222 @@
   }
 
   static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMultiMasterFontDictionary** out) {
-    if (!isAMultiMasterFontDictionary(podofoDoc, podofoObj)) return false;
+    if (!isMultiMasterFontDictionary(podofoDoc, podofoObj)) return false;
 
 
     *out = new SkPdfMultiMasterFontDictionary(&podofoDoc, &podofoObj);
     return true;
   }
 
-  static bool isAObject(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isObject(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isANull(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isNull(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return podofoObj.GetDataType() == ePdfDataType_Null;
   }
 
-  static bool isABoolean(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isBoolean(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return podofoObj.GetDataType() == ePdfDataType_Bool;
   }
 
-  static bool isAInteger(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isInteger(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return podofoObj.GetDataType() == ePdfDataType_Number;
   }
 
-  static bool isANumber(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isNumber(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return podofoObj.GetDataType() == ePdfDataType_Real;
   }
 
-  static bool isAName(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isName(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return podofoObj.GetDataType() == ePdfDataType_Name;
   }
 
-  static bool isAReference(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isReference(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return podofoObj.GetDataType() == ePdfDataType_Reference;
   }
 
-  static bool isAArray(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isArray(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return podofoObj.GetDataType() == ePdfDataType_Array;
   }
 
-  static bool isAString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return podofoObj.GetDataType() == ePdfDataType_String;
   }
 
-  static bool isAHexString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isHexString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return podofoObj.GetDataType() == ePdfDataType_HexString;
   }
 
-  static bool isADictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return podofoObj.GetDataType() == ePdfDataType_Dictionary;
   }
 
-  static bool isAXObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isXObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isATrueTypeFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isTrueTypeFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAStreamCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isStreamCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isALzwdecodeAndFlatedecodeFiltersDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isLzwdecodeAndFlatedecodeFiltersDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isACcittfaxdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isCcittfaxdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAJbig2DecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isJbig2DecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isADctdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isDctdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAFileTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isFileTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAEncryptionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isEncryptionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAStandardSecurityHandlerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isStandardSecurityHandlerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isACatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAPageTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isPageTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAPageObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isPageObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isANameDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isNameDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAResourceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isResourceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isANameTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isNameTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isANumberTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isNumberTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAFunctionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isFunctionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAType0FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isType0FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAType2FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isType2FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAType3FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isType3FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAFileSpecificationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isFileSpecificationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAEmbeddedFileParameterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isEmbeddedFileParameterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAMacOsFileInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isMacOsFileInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAGraphicsStateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isGraphicsStateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isACalgrayColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isCalgrayColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isACalrgbColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isCalrgbColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isALabColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isLabColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAIccProfileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isIccProfileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isADeviceNColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isDeviceNColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAType1PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isType1PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAType2PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isType2PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAType1ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isType1ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAType2ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isType2ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAType3ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isType3ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAType4ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isType4ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAType5ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isType5ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAType6ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isType6ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     std::string Subtype;
     if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
     if (Subtype != "Image") return false;
@@ -93363,11 +95427,11 @@
     return true;
   }
 
-  static bool isAAlternateImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isAlternateImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAType1FormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isType1FormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     std::string Subtype;
     if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
     if (Subtype != "Form") return false;
@@ -93375,495 +95439,495 @@
     return true;
   }
 
-  static bool isAGroupAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isGroupAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAPSXobjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isPSXobjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAType1FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isType1FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAType3FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isType3FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAEncodingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isEncodingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isACIDSystemInfoDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isCIDSystemInfoDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isACIDFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isCIDFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isACMapDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isCMapDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAType0FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isType0FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isACIDFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isCIDFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAEmbeddedFontStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isEmbeddedFontStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAType1HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isType1HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAType6HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isType6HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAType10HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isType10HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAType16HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isType16HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAType5HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isType5HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isASoftMaskDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isSoftMaskDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isASoftMaskImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isSoftMaskImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isATransparencyGroupDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isTransparencyGroupDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAViewerPreferencesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isViewerPreferencesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAOutlineDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isOutlineDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAOutlineItemDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isOutlineItemDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAPageLabelDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isPageLabelDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAThreadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isThreadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isABeadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isBeadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isATransitionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isTransitionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isABorderStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isBorderStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAAppearanceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isAppearanceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isATextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAALinkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isALinkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAFreeTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isFreeTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isALineAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isLineAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isASquareOrCircleAnnotation(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isSquareOrCircleAnnotation(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAMarkupAnnotationsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isMarkupAnnotationsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isARubberStampAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isRubberStampAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAInkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isInkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAPopUpAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isPopUpAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAFileAttachmentAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isFileAttachmentAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isASoundAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isSoundAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAMovieAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isMovieAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAWidgetAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isWidgetAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAAnnotationActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isAnnotationActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAPageObjectActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isPageObjectActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAFormFieldActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isFormFieldActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isADocumentCatalogActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isDocumentCatalogActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isARemoteGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isRemoteGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isALaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAWindowsLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isWindowsLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAThreadActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isThreadActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAURIActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isURIActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAURIDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isURIDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isASoundActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isSoundActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAMovieActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isMovieActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAHideActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isHideActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isANamedActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isNamedActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAInteractiveFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isInteractiveFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAVariableTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isVariableTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAAppearanceCharacteristicsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isAppearanceCharacteristicsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isACheckboxFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isCheckboxFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isARadioButtonFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isRadioButtonFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isATextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAChoiceFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isChoiceFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isASignatureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isSignatureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isASubmitFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isSubmitFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAResetFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isResetFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAImportDataActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isImportDataActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAJavascriptActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isJavascriptActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAFDFTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isFDFTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAFDFCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isFDFCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAFDFDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isFDFDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAEncryptedEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isEncryptedEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAJavascriptDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isJavascriptDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAFDFFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isFDFFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAIconFitDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isIconFitDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAFDFPageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isFDFPageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAFDFTemplateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isFDFTemplateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAFDFNamedPageReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isFDFNamedPageReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAFDFFileAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isFDFFileAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isASoundObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isSoundObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAMovieDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isMovieDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAMovieActivationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isMovieActivationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isADocumentInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isDocumentInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAMetadataStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isMetadataStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAComponentsWithMetadataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isComponentsWithMetadataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAPagePieceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isPagePieceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAApplicationDataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isApplicationDataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAStructureTreeRootDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isStructureTreeRootDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAStructureElementDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isStructureElementDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAMarkedContentReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isMarkedContentReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAObjectReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isObjectReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAStructureElementAccessDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isStructureElementAccessDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAAttributeObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isAttributeObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAMarkInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isMarkInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAArtifactsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isArtifactsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAStandardStructureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isStandardStructureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isABlockLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isBlockLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAInlineLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isInlineLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAListAttributeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isListAttributeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isATableAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isTableAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAWebCaptureInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isWebCaptureInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAWebCaptureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isWebCaptureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAWebCapturePageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isWebCapturePageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAWebCaptureImageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isWebCaptureImageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isASourceInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isSourceInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAURLAliasDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isURLAliasDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAWebCaptureCommandDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isWebCaptureCommandDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAWebCaptureCommandSettingsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isWebCaptureCommandSettingsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isABoxColorInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isBoxColorInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isABoxStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isBoxStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAPrinterMarkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isPrinterMarkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAPrinterMarkFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isPrinterMarkFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isASeparationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isSeparationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAPDF_XOutputIntentDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isPDF_XOutputIntentDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isATrapNetworkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isTrapNetworkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isATrapNetworkAppearanceStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isTrapNetworkAppearanceStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAOpiVersionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isOpiVersionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     return true;
   }
 
-  static bool isAMultiMasterFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  static bool isMultiMasterFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
     std::string Subtype;
     if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
     if (Subtype != "MMType1") return false;