Initial Check-in of PropertySets.java and .xsl. (Similar to Alt-Design's

PropertySets, however uses integer arrays to identify those properties
relevant for an FO.)


git-svn-id: https://svn.apache.org/repos/asf/xmlgraphics/fop/trunk@197050 13f79535-47bb-0310-9956-ffa450edef68

7 files changed, 1532 insertions, 4 deletions

diff --git a/build.xml b/build.xml
index d907a3501..5b308014e 100644
--- a/build.xml
+++ b/build.xml
@@ -920,6 +920,8 @@ list of possible build targets.
   <target name="xsltToJava" >
     <style in="src\codegen\constants.xml" style="src\codegen\constants.xsl"
         out="Constants.java"/>
+    <style in="src/codegen/foelements.xml" style="src/codegen/property-sets.xsl"
+        out="PropertySets.java"/>
   </target>
 
   <!-- =================================================================== -->
diff --git a/src/codegen/property-sets.xsl b/src/codegen/property-sets.xsl
new file mode 100644
index 000000000..09848b7d7
--- /dev/null
+++ b/src/codegen/property-sets.xsl
@@ -0,0 +1,235 @@
+<!-- $Id$
+============================================================================
+                   The Apache Software License, Version 1.1
+============================================================================
+
+Copyright (C) 1999-2003 The Apache Software Foundation. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modifica-
+tion, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. The end-user documentation included with the redistribution, if any, must
+   include the following acknowledgment: "This product includes software
+   developed by the Apache Software Foundation (http://www.apache.org/)."
+   Alternately, this acknowledgment may appear in the software itself, if
+   and wherever such third-party acknowledgments normally appear.
+
+4. The names "FOP" and "Apache Software Foundation" must not be used to
+   endorse or promote products derived from this software without prior
+   written permission. For written permission, please contact
+   apache@apache.org.
+
+5. Products derived from this software may not be called "Apache", nor may
+   "Apache" appear in their name, without prior written permission of the
+   Apache Software Foundation.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+APACHE SOFTWARE FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLU-
+DING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+============================================================================
+
+This software consists of voluntary contributions made by many individuals
+on behalf of the Apache Software Foundation and was originally created by
+James Tauber <jtauber@jtauber.com>. For more information on the Apache
+Software Foundation, please see <http://www.apache.org/>.
+--> 
+<xsl:stylesheet version="1.0"
+                xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+<xsl:output method="text" />
+
+<xsl:include href="propinc.xsl"/>
+
+<xsl:template match="root">
+  <xsl:text>
+package org.apache.fop.fo;
+import java.util.BitSet;
+
+public class PropertySets {
+    public static short[][] mapping = null;
+
+    public static void initialize() {
+        mapping = new short[Constants.ELEMENT_COUNT][];
+</xsl:text>
+  <xsl:apply-templates/>
+        <xsl:text>
+        boolean loop = true;
+        while (loop) {
+            loop = false;
+</xsl:text>
+<xsl:apply-templates mode="content"/>
+       }
+<xsl:apply-templates mode="mapping"/>
+  <xsl:text>
+    }
+
+    private static short[] makeSparseIndices(BitSet set) {
+        short[] indices = new short[Constants.PROPERTY_COUNT];
+        indices[0] = (short) (set.cardinality() + 1);
+        int j = 1;
+        for (int i = set.nextSetBit(0); i >= 0; i = set.nextSetBit(i+1)) {
+            indices[i] = (short) j++;
+        }
+        return indices;
+    }
+
+    private static boolean mergeContent(BitSet node, BitSet content,
+                                         boolean loop)
+    {
+        int c = node.cardinality();
+        node.or(content);
+        if (c == node.cardinality())
+            return loop;
+        return true;
+    }
+
+    public static short[] getPropertySet(int elementId) {
+        if (mapping == null)
+            initialize();
+        return mapping[elementId];
+    }
+}
+  </xsl:text>
+</xsl:template>
+
+<xsl:template match="common">
+  <xsl:variable name="name" select="name"/>
+  <xsl:text>
+        BitSet </xsl:text><xsl:value-of select="$name"/>
+  <xsl:text> = new BitSet();
+</xsl:text>
+  <xsl:apply-templates select="property">
+    <xsl:with-param name="setname" select="$name"/>
+  </xsl:apply-templates>
+</xsl:template>
+
+<xsl:template match="common/property">
+  <xsl:param name="setname"/>
+
+  <xsl:text>        </xsl:text>
+  <xsl:value-of select="../name"/><xsl:text>.set(Constants.PR_</xsl:text>
+  <xsl:call-template name="makeEnumConstant">
+    <xsl:with-param name="propstr" select="." />
+  </xsl:call-template>);
+</xsl:template>
+
+
+<xsl:template match="element">
+<!--
+  <xsl:text>
+  public static final int FO_</xsl:text>
+  <xsl:call-template name="makeEnumName">
+    <xsl:with-param name="propstr" select="name" />
+  </xsl:call-template>
+  <xsl:text> = </xsl:text>
+  <xsl:value-of select="count(preceding-sibling::element)"/>;
+-->
+
+  <xsl:variable name="name">
+    <xsl:text>fo_</xsl:text>
+    <xsl:value-of select="translate(name, '-', '_')"/>
+  </xsl:variable>
+  <xsl:text>
+        BitSet </xsl:text><xsl:value-of select="$name"/>
+  <xsl:text> = new BitSet();
+</xsl:text>
+  <xsl:apply-templates select="common-ref | property">
+    <xsl:with-param name="setname" select="$name"/>
+  </xsl:apply-templates>
+</xsl:template>
+
+
+<xsl:template match="element" mode="content">
+  <xsl:variable name="name">
+    <xsl:text>fo_</xsl:text>
+    <xsl:value-of select="translate(name, '-', '_')"/>
+  </xsl:variable>
+
+  <xsl:apply-templates select="content">
+    <xsl:with-param name="setname" select="$name"/>
+  </xsl:apply-templates>
+</xsl:template>
+
+
+<xsl:template match="element/content">
+  <xsl:param name="setname"/>
+
+  <xsl:variable name="name">
+    <xsl:text>fo_</xsl:text>
+    <xsl:value-of select="translate(., '-', '_')"/>
+  </xsl:variable>
+
+  <xsl:choose>
+    <xsl:when test=". = '%block;'">
+            loop = mergeContent(<xsl:value-of select="$setname"/>, fo_block, loop);
+            loop = mergeContent(<xsl:value-of select="$setname"/>, fo_block_container, loop);
+            loop = mergeContent(<xsl:value-of select="$setname"/>, fo_table_and_caption, loop);
+            loop = mergeContent(<xsl:value-of select="$setname"/>, fo_table, loop);
+            loop = mergeContent(<xsl:value-of select="$setname"/>, fo_list_block, loop);
+    </xsl:when>
+    <xsl:when test=". = '%inline;'">
+            loop = mergeContent(<xsl:value-of select="$setname"/>, fo_bidi_override, loop);
+            loop = mergeContent(<xsl:value-of select="$setname"/>, fo_character, loop);
+            loop = mergeContent(<xsl:value-of select="$setname"/>, fo_external_graphic, loop);
+            loop = mergeContent(<xsl:value-of select="$setname"/>, fo_instream_foreign_object, loop);
+            loop = mergeContent(<xsl:value-of select="$setname"/>, fo_inline, loop);
+            loop = mergeContent(<xsl:value-of select="$setname"/>, fo_inline_container, loop);
+            loop = mergeContent(<xsl:value-of select="$setname"/>, fo_leader, loop);
+            loop = mergeContent(<xsl:value-of select="$setname"/>, fo_page_number, loop);
+            loop = mergeContent(<xsl:value-of select="$setname"/>, fo_page_number_citation, loop);
+            loop = mergeContent(<xsl:value-of select="$setname"/>, fo_basic_link, loop);
+            loop = mergeContent(<xsl:value-of select="$setname"/>, fo_multi_toggle, loop);
+    </xsl:when>
+    <xsl:otherwise>
+            loop = mergeContent(<xsl:value-of select="$setname"/>, <xsl:value-of select="$name"/>, loop);
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match="element" mode="mapping">
+  <xsl:variable name="name">
+    <xsl:text>fo_</xsl:text>
+    <xsl:value-of select="translate(name, '-', '_')"/>
+  </xsl:variable>
+  <xsl:text>        mapping[Constants.</xsl:text>
+  <xsl:call-template name="makeEnumConstant">
+    <xsl:with-param name="propstr" select="$name" />
+  </xsl:call-template>] = makeSparseIndices(<xsl:value-of select="$name"/>);
+</xsl:template>
+
+<xsl:template match="element/common-ref">
+  <xsl:param name="setname"/>
+
+  <xsl:text>        </xsl:text>
+  <xsl:value-of select="$setname"/>.or(<xsl:value-of select="."/>);
+</xsl:template>
+
+<xsl:template match="element/property">
+  <xsl:param name="setname"/>
+
+  <xsl:text>        </xsl:text>
+  <xsl:value-of select="$setname"/><xsl:text>.set(Constants.PR_</xsl:text>
+  <xsl:call-template name="makeEnumConstant">
+    <xsl:with-param name="propstr" select="." />
+  </xsl:call-template>);
+</xsl:template>
+
+<xsl:template match="text()"/>
+<xsl:template match="text()" mode="content"/>
+<xsl:template match="text()" mode="mapping"/>
+
+</xsl:stylesheet>
+
diff --git a/src/java/org/apache/fop/fo/FObj.java b/src/java/org/apache/fop/fo/FObj.java
index 1f5fcaadd..ea0cf09d6 100644
--- a/src/java/org/apache/fop/fo/FObj.java
+++ b/src/java/org/apache/fop/fo/FObj.java
@@ -59,7 +59,6 @@ import java.util.Set;
 
 import org.apache.fop.apps.FOPException;
 import org.apache.fop.fo.flow.Marker;
-import org.apache.fop.fo.Constants;
 import org.apache.fop.fo.properties.FOPropertyMapping;
 import org.xml.sax.Attributes;
 
diff --git a/src/java/org/apache/fop/fo/Property.java b/src/java/org/apache/fop/fo/Property.java
index 30c323d03..592d28863 100644
--- a/src/java/org/apache/fop/fo/Property.java
+++ b/src/java/org/apache/fop/fo/Property.java
@@ -61,7 +61,6 @@ import org.apache.fop.datatypes.Space;
 import org.apache.fop.fo.expr.Numeric;
 import org.apache.fop.fo.expr.PropertyParser;
 import org.apache.fop.fo.expr.PropertyInfo;
-import org.apache.fop.fo.Constants;
 import org.apache.fop.fo.properties.FOPropertyMapping;
 import org.apache.fop.apps.FOPException;
 import java.util.Vector;
diff --git a/src/java/org/apache/fop/fo/PropertyList.java b/src/java/org/apache/fop/fo/PropertyList.java
index 0038a42e9..2ceac6681 100644
--- a/src/java/org/apache/fop/fo/PropertyList.java
+++ b/src/java/org/apache/fop/fo/PropertyList.java
@@ -57,7 +57,6 @@ import org.xml.sax.Attributes;
 // FOP
 import org.apache.fop.apps.FOPException;
 import org.apache.fop.fo.Property.Maker;
-import org.apache.fop.fo.Constants;
 import org.apache.fop.fo.properties.FOPropertyMapping;
 import org.apache.fop.fo.properties.WritingMode;
 
diff --git a/src/java/org/apache/fop/fo/PropertyManager.java b/src/java/org/apache/fop/fo/PropertyManager.java
index eaa51451f..0d8775c06 100644
--- a/src/java/org/apache/fop/fo/PropertyManager.java
+++ b/src/java/org/apache/fop/fo/PropertyManager.java
@@ -67,7 +67,6 @@ import org.apache.fop.traits.BlockProps;
 import org.apache.fop.traits.InlineProps;
 import org.apache.fop.traits.SpaceVal;
 import org.apache.fop.traits.LayoutProps; // keep, break, span, space?
-import org.apache.fop.fo.Constants;
 import org.apache.fop.fo.properties.Span;
 import org.apache.fop.fonts.FontMetrics;
 import org.apache.fop.fo.properties.CommonHyphenation;
diff --git a/src/java/org/apache/fop/fo/PropertySets.java b/src/java/org/apache/fop/fo/PropertySets.java
new file mode 100644
index 000000000..bdcb1f06d
--- /dev/null
+++ b/src/java/org/apache/fop/fo/PropertySets.java
@@ -0,0 +1,1295 @@
+/*
+ * $Id$
+ * ============================================================================
+ *                    The Apache Software License, Version 1.1
+ * ============================================================================
+ * 
+ * Copyright (C) 1999-2003 The Apache Software Foundation. All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modifica-
+ * tion, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ * 3. The end-user documentation included with the redistribution, if any, must
+ *    include the following acknowledgment: "This product includes software
+ *    developed by the Apache Software Foundation (http://www.apache.org/)."
+ *    Alternately, this acknowledgment may appear in the software itself, if
+ *    and wherever such third-party acknowledgments normally appear.
+ * 
+ * 4. The names "FOP" and "Apache Software Foundation" must not be used to
+ *    endorse or promote products derived from this software without prior
+ *    written permission. For written permission, please contact
+ *    apache@apache.org.
+ * 
+ * 5. Products derived from this software may not be called "Apache", nor may
+ *    "Apache" appear in their name, without prior written permission of the
+ *    Apache Software Foundation.
+ * 
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * APACHE SOFTWARE FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLU-
+ * DING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ============================================================================
+ * 
+ * This software consists of voluntary contributions made by many individuals
+ * on behalf of the Apache Software Foundation and was originally created by
+ * James Tauber <jtauber@jtauber.com>. For more information on the Apache
+ * Software Foundation, please see <http://www.apache.org/>.
+ */ 
+
+/* autogenerated from src/codegen/property-sets.xsl */
+
+package org.apache.fop.fo;
+import java.util.BitSet;
+
+public class PropertySets {
+    public static short[][] mapping = null;
+
+    public static void initialize() {
+        mapping = new short[Constants.ELEMENT_COUNT][];
+
+        BitSet CommonAccessibilityProperties = new BitSet();
+        CommonAccessibilityProperties.set(Constants.PR_SOURCE_DOCUMENT);
+        CommonAccessibilityProperties.set(Constants.PR_ROLE);
+
+        BitSet CommonAbsolutePositionProperties = new BitSet();
+        CommonAbsolutePositionProperties.set(Constants.PR_ABSOLUTE_POSITION);
+        CommonAbsolutePositionProperties.set(Constants.PR_POSITION);
+        CommonAbsolutePositionProperties.set(Constants.PR_TOP);
+        CommonAbsolutePositionProperties.set(Constants.PR_RIGHT);
+        CommonAbsolutePositionProperties.set(Constants.PR_BOTTOM);
+        CommonAbsolutePositionProperties.set(Constants.PR_LEFT);
+
+        BitSet CommonAuralProperties = new BitSet();
+        CommonAuralProperties.set(Constants.PR_AZIMUTH);
+        CommonAuralProperties.set(Constants.PR_CUE_AFTER);
+        CommonAuralProperties.set(Constants.PR_CUE_BEFORE);
+        CommonAuralProperties.set(Constants.PR_CUE);
+        CommonAuralProperties.set(Constants.PR_ELEVATION);
+        CommonAuralProperties.set(Constants.PR_PAUSE_AFTER);
+        CommonAuralProperties.set(Constants.PR_PAUSE_BEFORE);
+        CommonAuralProperties.set(Constants.PR_PAUSE);
+        CommonAuralProperties.set(Constants.PR_PITCH);
+        CommonAuralProperties.set(Constants.PR_PITCH_RANGE);
+        CommonAuralProperties.set(Constants.PR_PLAY_DURING);
+        CommonAuralProperties.set(Constants.PR_RICHNESS);
+        CommonAuralProperties.set(Constants.PR_SPEAK);
+        CommonAuralProperties.set(Constants.PR_SPEAK_HEADER);
+        CommonAuralProperties.set(Constants.PR_SPEAK_NUMERAL);
+        CommonAuralProperties.set(Constants.PR_SPEAK_PUNCTUATION);
+        CommonAuralProperties.set(Constants.PR_SPEECH_RATE);
+        CommonAuralProperties.set(Constants.PR_STRESS);
+        CommonAuralProperties.set(Constants.PR_VOICE_FAMILY);
+        CommonAuralProperties.set(Constants.PR_VOLUME);
+
+        BitSet CommonBorderPaddingBackgroundProperties = new BitSet();
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BACKGROUND_ATTACHMENT);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BACKGROUND_COLOR);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BACKGROUND_IMAGE);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BACKGROUND_REPEAT);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BACKGROUND_POSITION_HORIZONTAL);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BACKGROUND_POSITION_VERTICAL);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_BEFORE_COLOR);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_BEFORE_STYLE);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_BEFORE_WIDTH);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_AFTER_COLOR);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_AFTER_STYLE);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_AFTER_WIDTH);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_START_COLOR);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_START_STYLE);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_START_WIDTH);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_END_COLOR);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_END_STYLE);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_END_WIDTH);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_TOP_COLOR);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_TOP_STYLE);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_TOP_WIDTH);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_BOTTOM_COLOR);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_BOTTOM_STYLE);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_BOTTOM_WIDTH);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_LEFT_COLOR);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_LEFT_STYLE);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_LEFT_WIDTH);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_RIGHT_COLOR);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_RIGHT_STYLE);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_RIGHT_WIDTH);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_PADDING_BEFORE);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_PADDING_AFTER);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_PADDING_START);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_PADDING_END);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_PADDING_TOP);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_PADDING_BOTTOM);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_PADDING_LEFT);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_PADDING_RIGHT);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_STYLE);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_WIDTH);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_COLOR);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_TOP);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_BOTTOM);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_LEFT);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_BORDER_RIGHT);
+        CommonBorderPaddingBackgroundProperties.set(Constants.PR_PADDING);
+
+        BitSet CommonFontProperties = new BitSet();
+        CommonFontProperties.set(Constants.PR_FONT);
+        CommonFontProperties.set(Constants.PR_FONT_FAMILY);
+        CommonFontProperties.set(Constants.PR_FONT_SELECTION_STRATEGY);
+        CommonFontProperties.set(Constants.PR_FONT_SIZE);
+        CommonFontProperties.set(Constants.PR_FONT_STRETCH);
+        CommonFontProperties.set(Constants.PR_FONT_SIZE_ADJUST);
+        CommonFontProperties.set(Constants.PR_FONT_STYLE);
+        CommonFontProperties.set(Constants.PR_FONT_VARIANT);
+        CommonFontProperties.set(Constants.PR_FONT_WEIGHT);
+
+        BitSet CommonHyphenationProperties = new BitSet();
+        CommonHyphenationProperties.set(Constants.PR_COUNTRY);
+        CommonHyphenationProperties.set(Constants.PR_LANGUAGE);
+        CommonHyphenationProperties.set(Constants.PR_SCRIPT);
+        CommonHyphenationProperties.set(Constants.PR_HYPHENATE);
+        CommonHyphenationProperties.set(Constants.PR_HYPHENATION_CHARACTER);
+        CommonHyphenationProperties.set(Constants.PR_HYPHENATION_PUSH_CHARACTER_COUNT);
+        CommonHyphenationProperties.set(Constants.PR_HYPHENATION_REMAIN_CHARACTER_COUNT);
+
+        BitSet CommonMarginPropertiesBlock = new BitSet();
+        CommonMarginPropertiesBlock.set(Constants.PR_MARGIN);
+        CommonMarginPropertiesBlock.set(Constants.PR_MARGIN_TOP);
+        CommonMarginPropertiesBlock.set(Constants.PR_MARGIN_BOTTOM);
+        CommonMarginPropertiesBlock.set(Constants.PR_MARGIN_LEFT);
+        CommonMarginPropertiesBlock.set(Constants.PR_MARGIN_RIGHT);
+        CommonMarginPropertiesBlock.set(Constants.PR_SPACE_BEFORE);
+        CommonMarginPropertiesBlock.set(Constants.PR_SPACE_AFTER);
+        CommonMarginPropertiesBlock.set(Constants.PR_START_INDENT);
+        CommonMarginPropertiesBlock.set(Constants.PR_END_INDENT);
+
+        BitSet CommonMarginPropertiesInline = new BitSet();
+        CommonMarginPropertiesInline.set(Constants.PR_SPACE_END);
+        CommonMarginPropertiesInline.set(Constants.PR_SPACE_START);
+
+        BitSet CommonRelativePositionProperties = new BitSet();
+        CommonRelativePositionProperties.set(Constants.PR_RELATIVE_POSITION);
+
+        BitSet fo_root = new BitSet();
+        fo_root.set(Constants.PR_MEDIA_USAGE);
+
+        BitSet fo_declaration = new BitSet();
+
+        BitSet fo_color_profile = new BitSet();
+        fo_color_profile.set(Constants.PR_SRC);
+        fo_color_profile.set(Constants.PR_COLOR_PROFILE_NAME);
+        fo_color_profile.set(Constants.PR_RENDERING_INTENT);
+
+        BitSet fo_page_sequence = new BitSet();
+        fo_page_sequence.set(Constants.PR_COUNTRY);
+        fo_page_sequence.set(Constants.PR_FORMAT);
+        fo_page_sequence.set(Constants.PR_LANGUAGE);
+        fo_page_sequence.set(Constants.PR_LETTER_VALUE);
+        fo_page_sequence.set(Constants.PR_GROUPING_SEPARATOR);
+        fo_page_sequence.set(Constants.PR_GROUPING_SIZE);
+        fo_page_sequence.set(Constants.PR_ID);
+        fo_page_sequence.set(Constants.PR_INITIAL_PAGE_NUMBER);
+        fo_page_sequence.set(Constants.PR_FORCE_PAGE_COUNT);
+        fo_page_sequence.set(Constants.PR_MASTER_REFERENCE);
+
+        BitSet fo_layout_master_set = new BitSet();
+        fo_layout_master_set.set(Constants.PR_MASTER_NAME);
+
+        BitSet fo_page_sequence_master = new BitSet();
+        fo_page_sequence_master.set(Constants.PR_MASTER_NAME);
+
+        BitSet fo_single_page_master_reference = new BitSet();
+        fo_single_page_master_reference.set(Constants.PR_MASTER_REFERENCE);
+
+        BitSet fo_repeatable_page_master_reference = new BitSet();
+        fo_repeatable_page_master_reference.set(Constants.PR_MASTER_REFERENCE);
+        fo_repeatable_page_master_reference.set(Constants.PR_MAXIMUM_REPEATS);
+
+        BitSet fo_repeatable_page_master_alternatives = new BitSet();
+        fo_repeatable_page_master_alternatives.set(Constants.PR_MAXIMUM_REPEATS);
+
+        BitSet fo_conditional_page_master_reference = new BitSet();
+        fo_conditional_page_master_reference.set(Constants.PR_MASTER_REFERENCE);
+        fo_conditional_page_master_reference.set(Constants.PR_PAGE_POSITION);
+        fo_conditional_page_master_reference.set(Constants.PR_ODD_OR_EVEN);
+        fo_conditional_page_master_reference.set(Constants.PR_BLANK_OR_NOT_BLANK);
+
+        BitSet fo_simple_page_master = new BitSet();
+        fo_simple_page_master.or(CommonMarginPropertiesBlock);
+        fo_simple_page_master.set(Constants.PR_MASTER_NAME);
+        fo_simple_page_master.set(Constants.PR_PAGE_HEIGHT);
+        fo_simple_page_master.set(Constants.PR_PAGE_WIDTH);
+        fo_simple_page_master.set(Constants.PR_REFERENCE_ORIENTATION);
+        fo_simple_page_master.set(Constants.PR_WRITING_MODE);
+
+        BitSet fo_region_body = new BitSet();
+        fo_region_body.or(CommonBorderPaddingBackgroundProperties);
+        fo_region_body.or(CommonMarginPropertiesBlock);
+        fo_region_body.set(Constants.PR_CLIP);
+        fo_region_body.set(Constants.PR_COLUMN_COUNT);
+        fo_region_body.set(Constants.PR_COLUMN_GAP);
+        fo_region_body.set(Constants.PR_DISPLAY_ALIGN);
+        fo_region_body.set(Constants.PR_OVERFLOW);
+        fo_region_body.set(Constants.PR_REGION_NAME);
+        fo_region_body.set(Constants.PR_REFERENCE_ORIENTATION);
+        fo_region_body.set(Constants.PR_WRITING_MODE);
+
+        BitSet fo_region_before = new BitSet();
+        fo_region_before.or(CommonBorderPaddingBackgroundProperties);
+        fo_region_before.set(Constants.PR_CLIP);
+        fo_region_before.set(Constants.PR_DISPLAY_ALIGN);
+        fo_region_before.set(Constants.PR_EXTENT);
+        fo_region_before.set(Constants.PR_OVERFLOW);
+        fo_region_before.set(Constants.PR_PRECEDENCE);
+        fo_region_before.set(Constants.PR_REGION_NAME);
+        fo_region_before.set(Constants.PR_REFERENCE_ORIENTATION);
+        fo_region_before.set(Constants.PR_WRITING_MODE);
+
+        BitSet fo_region_after = new BitSet();
+        fo_region_after.or(CommonBorderPaddingBackgroundProperties);
+        fo_region_after.set(Constants.PR_CLIP);
+        fo_region_after.set(Constants.PR_DISPLAY_ALIGN);
+        fo_region_after.set(Constants.PR_EXTENT);
+        fo_region_after.set(Constants.PR_OVERFLOW);
+        fo_region_after.set(Constants.PR_PRECEDENCE);
+        fo_region_after.set(Constants.PR_REGION_NAME);
+        fo_region_after.set(Constants.PR_REFERENCE_ORIENTATION);
+        fo_region_after.set(Constants.PR_WRITING_MODE);
+
+        BitSet fo_region_start = new BitSet();
+        fo_region_start.or(CommonBorderPaddingBackgroundProperties);
+        fo_region_start.set(Constants.PR_CLIP);
+        fo_region_start.set(Constants.PR_DISPLAY_ALIGN);
+        fo_region_start.set(Constants.PR_EXTENT);
+        fo_region_start.set(Constants.PR_OVERFLOW);
+        fo_region_start.set(Constants.PR_REGION_NAME);
+        fo_region_start.set(Constants.PR_REFERENCE_ORIENTATION);
+        fo_region_start.set(Constants.PR_WRITING_MODE);
+
+        BitSet fo_region_end = new BitSet();
+        fo_region_end.or(CommonBorderPaddingBackgroundProperties);
+        fo_region_end.set(Constants.PR_CLIP);
+        fo_region_end.set(Constants.PR_DISPLAY_ALIGN);
+        fo_region_end.set(Constants.PR_EXTENT);
+        fo_region_end.set(Constants.PR_OVERFLOW);
+        fo_region_end.set(Constants.PR_REGION_NAME);
+        fo_region_end.set(Constants.PR_REFERENCE_ORIENTATION);
+        fo_region_end.set(Constants.PR_WRITING_MODE);
+
+        BitSet fo_flow = new BitSet();
+        fo_flow.set(Constants.PR_FLOW_NAME);
+
+        BitSet fo_static_content = new BitSet();
+        fo_static_content.set(Constants.PR_FLOW_NAME);
+
+        BitSet fo_title = new BitSet();
+        fo_title.or(CommonAccessibilityProperties);
+        fo_title.or(CommonAuralProperties);
+        fo_title.or(CommonBorderPaddingBackgroundProperties);
+        fo_title.or(CommonFontProperties);
+        fo_title.or(CommonMarginPropertiesInline);
+        fo_title.set(Constants.PR_COLOR);
+        fo_title.set(Constants.PR_LINE_HEIGHT);
+        fo_title.set(Constants.PR_VISIBILITY);
+
+        BitSet fo_block = new BitSet();
+        fo_block.or(CommonAccessibilityProperties);
+        fo_block.or(CommonAuralProperties);
+        fo_block.or(CommonBorderPaddingBackgroundProperties);
+        fo_block.or(CommonFontProperties);
+        fo_block.or(CommonHyphenationProperties);
+        fo_block.or(CommonMarginPropertiesBlock);
+        fo_block.or(CommonRelativePositionProperties);
+        fo_block.set(Constants.PR_PAGE_BREAK_AFTER);
+        fo_block.set(Constants.PR_PAGE_BREAK_BEFORE);
+        fo_block.set(Constants.PR_BREAK_AFTER);
+        fo_block.set(Constants.PR_BREAK_BEFORE);
+        fo_block.set(Constants.PR_COLOR);
+        fo_block.set(Constants.PR_TEXT_DEPTH);
+        fo_block.set(Constants.PR_TEXT_ALTITUDE);
+        fo_block.set(Constants.PR_HYPHENATION_KEEP);
+        fo_block.set(Constants.PR_HYPHENATION_LADDER_COUNT);
+        fo_block.set(Constants.PR_ID);
+        fo_block.set(Constants.PR_PAGE_BREAK_INSIDE);
+        fo_block.set(Constants.PR_KEEP_TOGETHER);
+        fo_block.set(Constants.PR_KEEP_WITH_NEXT);
+        fo_block.set(Constants.PR_KEEP_WITH_PREVIOUS);
+        fo_block.set(Constants.PR_LAST_LINE_END_INDENT);
+        fo_block.set(Constants.PR_LINEFEED_TREATMENT);
+        fo_block.set(Constants.PR_LINE_HEIGHT);
+        fo_block.set(Constants.PR_LINE_HEIGHT_SHIFT_ADJUSTMENT);
+        fo_block.set(Constants.PR_LINE_STACKING_STRATEGY);
+        fo_block.set(Constants.PR_ORPHANS);
+        fo_block.set(Constants.PR_WHITE_SPACE_TREATMENT);
+        fo_block.set(Constants.PR_SPAN);
+        fo_block.set(Constants.PR_TEXT_ALIGN);
+        fo_block.set(Constants.PR_TEXT_ALIGN_LAST);
+        fo_block.set(Constants.PR_TEXT_INDENT);
+        fo_block.set(Constants.PR_VISIBILITY);
+        fo_block.set(Constants.PR_WHITE_SPACE_COLLAPSE);
+        fo_block.set(Constants.PR_WIDOWS);
+        fo_block.set(Constants.PR_WRAP_OPTION);
+
+        BitSet fo_block_container = new BitSet();
+        fo_block_container.or(CommonAbsolutePositionProperties);
+        fo_block_container.or(CommonBorderPaddingBackgroundProperties);
+        fo_block_container.or(CommonMarginPropertiesBlock);
+        fo_block_container.set(Constants.PR_BLOCK_PROGRESSION_DIMENSION);
+        fo_block_container.set(Constants.PR_PAGE_BREAK_AFTER);
+        fo_block_container.set(Constants.PR_PAGE_BREAK_BEFORE);
+        fo_block_container.set(Constants.PR_BREAK_AFTER);
+        fo_block_container.set(Constants.PR_BREAK_BEFORE);
+        fo_block_container.set(Constants.PR_CLIP);
+        fo_block_container.set(Constants.PR_DISPLAY_ALIGN);
+        fo_block_container.set(Constants.PR_HEIGHT);
+        fo_block_container.set(Constants.PR_ID);
+        fo_block_container.set(Constants.PR_INLINE_PROGRESSION_DIMENSION);
+        fo_block_container.set(Constants.PR_PAGE_BREAK_INSIDE);
+        fo_block_container.set(Constants.PR_KEEP_TOGETHER);
+        fo_block_container.set(Constants.PR_KEEP_WITH_NEXT);
+        fo_block_container.set(Constants.PR_KEEP_WITH_PREVIOUS);
+        fo_block_container.set(Constants.PR_OVERFLOW);
+        fo_block_container.set(Constants.PR_REFERENCE_ORIENTATION);
+        fo_block_container.set(Constants.PR_SPAN);
+        fo_block_container.set(Constants.PR_WIDTH);
+        fo_block_container.set(Constants.PR_WRITING_MODE);
+        fo_block_container.set(Constants.PR_Z_INDEX);
+
+        BitSet fo_bidi_override = new BitSet();
+        fo_bidi_override.or(CommonAuralProperties);
+        fo_bidi_override.or(CommonFontProperties);
+        fo_bidi_override.or(CommonRelativePositionProperties);
+        fo_bidi_override.set(Constants.PR_COLOR);
+        fo_bidi_override.set(Constants.PR_DIRECTION);
+        fo_bidi_override.set(Constants.PR_ID);
+        fo_bidi_override.set(Constants.PR_LETTER_SPACING);
+        fo_bidi_override.set(Constants.PR_LINE_HEIGHT);
+        fo_bidi_override.set(Constants.PR_SCORE_SPACES);
+        fo_bidi_override.set(Constants.PR_UNICODE_BIDI);
+        fo_bidi_override.set(Constants.PR_WORD_SPACING);
+
+        BitSet fo_character = new BitSet();
+        fo_character.or(CommonAuralProperties);
+        fo_character.or(CommonBorderPaddingBackgroundProperties);
+        fo_character.or(CommonFontProperties);
+        fo_character.or(CommonHyphenationProperties);
+        fo_character.or(CommonMarginPropertiesInline);
+        fo_character.or(CommonRelativePositionProperties);
+        fo_character.set(Constants.PR_VERTICAL_ALIGN);
+        fo_character.set(Constants.PR_ALIGNMENT_ADJUST);
+        fo_character.set(Constants.PR_TREAT_AS_WORD_SPACE);
+        fo_character.set(Constants.PR_ALIGNMENT_BASELINE);
+        fo_character.set(Constants.PR_BASELINE_SHIFT);
+        fo_character.set(Constants.PR_CHARACTER);
+        fo_character.set(Constants.PR_COLOR);
+        fo_character.set(Constants.PR_DOMINANT_BASELINE);
+        fo_character.set(Constants.PR_TEXT_DEPTH);
+        fo_character.set(Constants.PR_TEXT_ALTITUDE);
+        fo_character.set(Constants.PR_GLYPH_ORIENTATION_HORIZONTAL);
+        fo_character.set(Constants.PR_GLYPH_ORIENTATION_VERTICAL);
+        fo_character.set(Constants.PR_ID);
+        fo_character.set(Constants.PR_KEEP_WITH_NEXT);
+        fo_character.set(Constants.PR_KEEP_WITH_PREVIOUS);
+        fo_character.set(Constants.PR_LETTER_SPACING);
+        fo_character.set(Constants.PR_LINE_HEIGHT);
+        fo_character.set(Constants.PR_SCORE_SPACES);
+        fo_character.set(Constants.PR_SUPPRESS_AT_LINE_BREAK);
+        fo_character.set(Constants.PR_TEXT_DECORATION);
+        fo_character.set(Constants.PR_TEXT_SHADOW);
+        fo_character.set(Constants.PR_TEXT_TRANSFORM);
+        fo_character.set(Constants.PR_VISIBILITY);
+        fo_character.set(Constants.PR_WORD_SPACING);
+
+        BitSet fo_initial_property_set = new BitSet();
+        fo_initial_property_set.or(CommonAccessibilityProperties);
+        fo_initial_property_set.or(CommonAuralProperties);
+        fo_initial_property_set.or(CommonBorderPaddingBackgroundProperties);
+        fo_initial_property_set.or(CommonFontProperties);
+        fo_initial_property_set.or(CommonRelativePositionProperties);
+        fo_initial_property_set.set(Constants.PR_COLOR);
+        fo_initial_property_set.set(Constants.PR_ID);
+        fo_initial_property_set.set(Constants.PR_LETTER_SPACING);
+        fo_initial_property_set.set(Constants.PR_LINE_HEIGHT);
+        fo_initial_property_set.set(Constants.PR_SCORE_SPACES);
+        fo_initial_property_set.set(Constants.PR_TEXT_DECORATION);
+        fo_initial_property_set.set(Constants.PR_TEXT_SHADOW);
+        fo_initial_property_set.set(Constants.PR_TEXT_TRANSFORM);
+        fo_initial_property_set.set(Constants.PR_WORD_SPACING);
+
+        BitSet fo_external_graphic = new BitSet();
+        fo_external_graphic.or(CommonAccessibilityProperties);
+        fo_external_graphic.or(CommonAuralProperties);
+        fo_external_graphic.or(CommonBorderPaddingBackgroundProperties);
+        fo_external_graphic.or(CommonMarginPropertiesInline);
+        fo_external_graphic.or(CommonRelativePositionProperties);
+        fo_external_graphic.set(Constants.PR_VERTICAL_ALIGN);
+        fo_external_graphic.set(Constants.PR_ALIGNMENT_ADJUST);
+        fo_external_graphic.set(Constants.PR_ALIGNMENT_BASELINE);
+        fo_external_graphic.set(Constants.PR_BASELINE_SHIFT);
+        fo_external_graphic.set(Constants.PR_BLOCK_PROGRESSION_DIMENSION);
+        fo_external_graphic.set(Constants.PR_CLIP);
+        fo_external_graphic.set(Constants.PR_CONTENT_HEIGHT);
+        fo_external_graphic.set(Constants.PR_CONTENT_TYPE);
+        fo_external_graphic.set(Constants.PR_CONTENT_WIDTH);
+        fo_external_graphic.set(Constants.PR_DISPLAY_ALIGN);
+        fo_external_graphic.set(Constants.PR_DOMINANT_BASELINE);
+        fo_external_graphic.set(Constants.PR_HEIGHT);
+        fo_external_graphic.set(Constants.PR_ID);
+        fo_external_graphic.set(Constants.PR_INLINE_PROGRESSION_DIMENSION);
+        fo_external_graphic.set(Constants.PR_KEEP_WITH_NEXT);
+        fo_external_graphic.set(Constants.PR_KEEP_WITH_PREVIOUS);
+        fo_external_graphic.set(Constants.PR_LINE_HEIGHT);
+        fo_external_graphic.set(Constants.PR_OVERFLOW);
+        fo_external_graphic.set(Constants.PR_SCALING);
+        fo_external_graphic.set(Constants.PR_SCALING_METHOD);
+        fo_external_graphic.set(Constants.PR_SRC);
+        fo_external_graphic.set(Constants.PR_TEXT_ALIGN);
+        fo_external_graphic.set(Constants.PR_WIDTH);
+
+        BitSet fo_instream_foreign_object = new BitSet();
+        fo_instream_foreign_object.or(CommonAccessibilityProperties);
+        fo_instream_foreign_object.or(CommonAuralProperties);
+        fo_instream_foreign_object.or(CommonBorderPaddingBackgroundProperties);
+        fo_instream_foreign_object.or(CommonMarginPropertiesInline);
+        fo_instream_foreign_object.or(CommonRelativePositionProperties);
+        fo_instream_foreign_object.set(Constants.PR_VERTICAL_ALIGN);
+        fo_instream_foreign_object.set(Constants.PR_ALIGNMENT_ADJUST);
+        fo_instream_foreign_object.set(Constants.PR_ALIGNMENT_BASELINE);
+        fo_instream_foreign_object.set(Constants.PR_BASELINE_SHIFT);
+        fo_instream_foreign_object.set(Constants.PR_BLOCK_PROGRESSION_DIMENSION);
+        fo_instream_foreign_object.set(Constants.PR_CLIP);
+        fo_instream_foreign_object.set(Constants.PR_CONTENT_HEIGHT);
+        fo_instream_foreign_object.set(Constants.PR_CONTENT_TYPE);
+        fo_instream_foreign_object.set(Constants.PR_CONTENT_WIDTH);
+        fo_instream_foreign_object.set(Constants.PR_DISPLAY_ALIGN);
+        fo_instream_foreign_object.set(Constants.PR_DOMINANT_BASELINE);
+        fo_instream_foreign_object.set(Constants.PR_HEIGHT);
+        fo_instream_foreign_object.set(Constants.PR_ID);
+        fo_instream_foreign_object.set(Constants.PR_INLINE_PROGRESSION_DIMENSION);
+        fo_instream_foreign_object.set(Constants.PR_KEEP_WITH_NEXT);
+        fo_instream_foreign_object.set(Constants.PR_KEEP_WITH_PREVIOUS);
+        fo_instream_foreign_object.set(Constants.PR_LINE_HEIGHT);
+        fo_instream_foreign_object.set(Constants.PR_OVERFLOW);
+        fo_instream_foreign_object.set(Constants.PR_SCALING);
+        fo_instream_foreign_object.set(Constants.PR_SCALING_METHOD);
+        fo_instream_foreign_object.set(Constants.PR_TEXT_ALIGN);
+        fo_instream_foreign_object.set(Constants.PR_WIDTH);
+
+        BitSet fo_inline = new BitSet();
+        fo_inline.or(CommonAccessibilityProperties);
+        fo_inline.or(CommonAuralProperties);
+        fo_inline.or(CommonBorderPaddingBackgroundProperties);
+        fo_inline.or(CommonFontProperties);
+        fo_inline.or(CommonMarginPropertiesInline);
+        fo_inline.or(CommonRelativePositionProperties);
+        fo_inline.set(Constants.PR_VERTICAL_ALIGN);
+        fo_inline.set(Constants.PR_ALIGNMENT_ADJUST);
+        fo_inline.set(Constants.PR_ALIGNMENT_BASELINE);
+        fo_inline.set(Constants.PR_BASELINE_SHIFT);
+        fo_inline.set(Constants.PR_BLOCK_PROGRESSION_DIMENSION);
+        fo_inline.set(Constants.PR_COLOR);
+        fo_inline.set(Constants.PR_DOMINANT_BASELINE);
+        fo_inline.set(Constants.PR_HEIGHT);
+        fo_inline.set(Constants.PR_ID);
+        fo_inline.set(Constants.PR_INLINE_PROGRESSION_DIMENSION);
+        fo_inline.set(Constants.PR_PAGE_BREAK_INSIDE);
+        fo_inline.set(Constants.PR_KEEP_TOGETHER);
+        fo_inline.set(Constants.PR_KEEP_WITH_NEXT);
+        fo_inline.set(Constants.PR_KEEP_WITH_PREVIOUS);
+        fo_inline.set(Constants.PR_LINE_HEIGHT);
+        fo_inline.set(Constants.PR_TEXT_DECORATION);
+        fo_inline.set(Constants.PR_VISIBILITY);
+        fo_inline.set(Constants.PR_WIDTH);
+        fo_inline.set(Constants.PR_WRAP_OPTION);
+
+        BitSet fo_inline_container = new BitSet();
+        fo_inline_container.or(CommonBorderPaddingBackgroundProperties);
+        fo_inline_container.or(CommonMarginPropertiesInline);
+        fo_inline_container.or(CommonRelativePositionProperties);
+        fo_inline_container.set(Constants.PR_VERTICAL_ALIGN);
+        fo_inline_container.set(Constants.PR_ALIGNMENT_ADJUST);
+        fo_inline_container.set(Constants.PR_ALIGNMENT_BASELINE);
+        fo_inline_container.set(Constants.PR_BASELINE_SHIFT);
+        fo_inline_container.set(Constants.PR_BLOCK_PROGRESSION_DIMENSION);
+        fo_inline_container.set(Constants.PR_CLIP);
+        fo_inline_container.set(Constants.PR_DISPLAY_ALIGN);
+        fo_inline_container.set(Constants.PR_DOMINANT_BASELINE);
+        fo_inline_container.set(Constants.PR_HEIGHT);
+        fo_inline_container.set(Constants.PR_ID);
+        fo_inline_container.set(Constants.PR_INLINE_PROGRESSION_DIMENSION);
+        fo_inline_container.set(Constants.PR_PAGE_BREAK_INSIDE);
+        fo_inline_container.set(Constants.PR_KEEP_TOGETHER);
+        fo_inline_container.set(Constants.PR_KEEP_WITH_NEXT);
+        fo_inline_container.set(Constants.PR_KEEP_WITH_PREVIOUS);
+        fo_inline_container.set(Constants.PR_LINE_HEIGHT);
+        fo_inline_container.set(Constants.PR_OVERFLOW);
+        fo_inline_container.set(Constants.PR_REFERENCE_ORIENTATION);
+        fo_inline_container.set(Constants.PR_WIDTH);
+        fo_inline_container.set(Constants.PR_WRITING_MODE);
+
+        BitSet fo_leader = new BitSet();
+        fo_leader.or(CommonAccessibilityProperties);
+        fo_leader.or(CommonAuralProperties);
+        fo_leader.or(CommonBorderPaddingBackgroundProperties);
+        fo_leader.or(CommonFontProperties);
+        fo_leader.or(CommonMarginPropertiesInline);
+        fo_leader.or(CommonRelativePositionProperties);
+        fo_leader.set(Constants.PR_VERTICAL_ALIGN);
+        fo_leader.set(Constants.PR_ALIGNMENT_ADJUST);
+        fo_leader.set(Constants.PR_ALIGNMENT_BASELINE);
+        fo_leader.set(Constants.PR_BASELINE_SHIFT);
+        fo_leader.set(Constants.PR_COLOR);
+        fo_leader.set(Constants.PR_DOMINANT_BASELINE);
+        fo_leader.set(Constants.PR_TEXT_DEPTH);
+        fo_leader.set(Constants.PR_TEXT_ALTITUDE);
+        fo_leader.set(Constants.PR_ID);
+        fo_leader.set(Constants.PR_KEEP_WITH_NEXT);
+        fo_leader.set(Constants.PR_KEEP_WITH_PREVIOUS);
+        fo_leader.set(Constants.PR_LEADER_ALIGNMENT);
+        fo_leader.set(Constants.PR_LEADER_LENGTH);
+        fo_leader.set(Constants.PR_LEADER_PATTERN);
+        fo_leader.set(Constants.PR_LEADER_PATTERN_WIDTH);
+        fo_leader.set(Constants.PR_RULE_STYLE);
+        fo_leader.set(Constants.PR_RULE_THICKNESS);
+        fo_leader.set(Constants.PR_LETTER_SPACING);
+        fo_leader.set(Constants.PR_LINE_HEIGHT);
+        fo_leader.set(Constants.PR_TEXT_SHADOW);
+        fo_leader.set(Constants.PR_VISIBILITY);
+        fo_leader.set(Constants.PR_WORD_SPACING);
+
+        BitSet fo_page_number = new BitSet();
+        fo_page_number.or(CommonAccessibilityProperties);
+        fo_page_number.or(CommonAuralProperties);
+        fo_page_number.or(CommonBorderPaddingBackgroundProperties);
+        fo_page_number.or(CommonFontProperties);
+        fo_page_number.or(CommonMarginPropertiesInline);
+        fo_page_number.or(CommonRelativePositionProperties);
+        fo_page_number.set(Constants.PR_VERTICAL_ALIGN);
+        fo_page_number.set(Constants.PR_ALIGNMENT_ADJUST);
+        fo_page_number.set(Constants.PR_ALIGNMENT_BASELINE);
+        fo_page_number.set(Constants.PR_BASELINE_SHIFT);
+        fo_page_number.set(Constants.PR_DOMINANT_BASELINE);
+        fo_page_number.set(Constants.PR_ID);
+        fo_page_number.set(Constants.PR_KEEP_WITH_NEXT);
+        fo_page_number.set(Constants.PR_KEEP_WITH_PREVIOUS);
+        fo_page_number.set(Constants.PR_LETTER_SPACING);
+        fo_page_number.set(Constants.PR_LINE_HEIGHT);
+        fo_page_number.set(Constants.PR_SCORE_SPACES);
+        fo_page_number.set(Constants.PR_TEXT_ALTITUDE);
+        fo_page_number.set(Constants.PR_TEXT_DECORATION);
+        fo_page_number.set(Constants.PR_TEXT_DEPTH);
+        fo_page_number.set(Constants.PR_TEXT_SHADOW);
+        fo_page_number.set(Constants.PR_TEXT_TRANSFORM);
+        fo_page_number.set(Constants.PR_VISIBILITY);
+        fo_page_number.set(Constants.PR_WORD_SPACING);
+        fo_page_number.set(Constants.PR_WRAP_OPTION);
+
+        BitSet fo_page_number_citation = new BitSet();
+        fo_page_number_citation.or(CommonAccessibilityProperties);
+        fo_page_number_citation.or(CommonAuralProperties);
+        fo_page_number_citation.or(CommonBorderPaddingBackgroundProperties);
+        fo_page_number_citation.or(CommonFontProperties);
+        fo_page_number_citation.or(CommonMarginPropertiesInline);
+        fo_page_number_citation.or(CommonRelativePositionProperties);
+        fo_page_number_citation.set(Constants.PR_VERTICAL_ALIGN);
+        fo_page_number_citation.set(Constants.PR_ALIGNMENT_ADJUST);
+        fo_page_number_citation.set(Constants.PR_ALIGNMENT_BASELINE);
+        fo_page_number_citation.set(Constants.PR_BASELINE_SHIFT);
+        fo_page_number_citation.set(Constants.PR_DOMINANT_BASELINE);
+        fo_page_number_citation.set(Constants.PR_ID);
+        fo_page_number_citation.set(Constants.PR_KEEP_WITH_NEXT);
+        fo_page_number_citation.set(Constants.PR_KEEP_WITH_PREVIOUS);
+        fo_page_number_citation.set(Constants.PR_LETTER_SPACING);
+        fo_page_number_citation.set(Constants.PR_LINE_HEIGHT);
+        fo_page_number_citation.set(Constants.PR_REF_ID);
+        fo_page_number_citation.set(Constants.PR_SCORE_SPACES);
+        fo_page_number_citation.set(Constants.PR_TEXT_ALTITUDE);
+        fo_page_number_citation.set(Constants.PR_TEXT_DECORATION);
+        fo_page_number_citation.set(Constants.PR_TEXT_DEPTH);
+        fo_page_number_citation.set(Constants.PR_TEXT_SHADOW);
+        fo_page_number_citation.set(Constants.PR_TEXT_TRANSFORM);
+        fo_page_number_citation.set(Constants.PR_VISIBILITY);
+        fo_page_number_citation.set(Constants.PR_WORD_SPACING);
+        fo_page_number_citation.set(Constants.PR_WRAP_OPTION);
+
+        BitSet fo_table_and_caption = new BitSet();
+        fo_table_and_caption.or(CommonAccessibilityProperties);
+        fo_table_and_caption.or(CommonAuralProperties);
+        fo_table_and_caption.or(CommonBorderPaddingBackgroundProperties);
+        fo_table_and_caption.or(CommonMarginPropertiesBlock);
+        fo_table_and_caption.or(CommonRelativePositionProperties);
+        fo_table_and_caption.set(Constants.PR_PAGE_BREAK_AFTER);
+        fo_table_and_caption.set(Constants.PR_PAGE_BREAK_BEFORE);
+        fo_table_and_caption.set(Constants.PR_BREAK_AFTER);
+        fo_table_and_caption.set(Constants.PR_BREAK_BEFORE);
+        fo_table_and_caption.set(Constants.PR_CAPTION_SIDE);
+        fo_table_and_caption.set(Constants.PR_ID);
+        fo_table_and_caption.set(Constants.PR_PAGE_BREAK_INSIDE);
+        fo_table_and_caption.set(Constants.PR_KEEP_TOGETHER);
+        fo_table_and_caption.set(Constants.PR_KEEP_WITH_NEXT);
+        fo_table_and_caption.set(Constants.PR_KEEP_WITH_PREVIOUS);
+        fo_table_and_caption.set(Constants.PR_TEXT_ALIGN);
+
+        BitSet fo_table = new BitSet();
+        fo_table.or(CommonAccessibilityProperties);
+        fo_table.or(CommonAuralProperties);
+        fo_table.or(CommonBorderPaddingBackgroundProperties);
+        fo_table.or(CommonMarginPropertiesBlock);
+        fo_table.or(CommonRelativePositionProperties);
+        fo_table.set(Constants.PR_BLOCK_PROGRESSION_DIMENSION);
+        fo_table.set(Constants.PR_BORDER_AFTER_PRECEDENCE);
+        fo_table.set(Constants.PR_BORDER_BEFORE_PRECEDENCE);
+        fo_table.set(Constants.PR_BORDER_SPACING);
+        fo_table.set(Constants.PR_BORDER_COLLAPSE);
+        fo_table.set(Constants.PR_BORDER_END_PRECEDENCE);
+        fo_table.set(Constants.PR_BORDER_SEPARATION);
+        fo_table.set(Constants.PR_BORDER_START_PRECEDENCE);
+        fo_table.set(Constants.PR_PAGE_BREAK_AFTER);
+        fo_table.set(Constants.PR_PAGE_BREAK_BEFORE);
+        fo_table.set(Constants.PR_BREAK_AFTER);
+        fo_table.set(Constants.PR_BREAK_BEFORE);
+        fo_table.set(Constants.PR_ID);
+        fo_table.set(Constants.PR_INLINE_PROGRESSION_DIMENSION);
+        fo_table.set(Constants.PR_HEIGHT);
+        fo_table.set(Constants.PR_PAGE_BREAK_INSIDE);
+        fo_table.set(Constants.PR_KEEP_TOGETHER);
+        fo_table.set(Constants.PR_KEEP_WITH_NEXT);
+        fo_table.set(Constants.PR_KEEP_WITH_PREVIOUS);
+        fo_table.set(Constants.PR_TABLE_LAYOUT);
+        fo_table.set(Constants.PR_TABLE_OMIT_FOOTER_AT_BREAK);
+        fo_table.set(Constants.PR_TABLE_OMIT_HEADER_AT_BREAK);
+        fo_table.set(Constants.PR_WIDTH);
+        fo_table.set(Constants.PR_WRITING_MODE);
+
+        BitSet fo_table_column = new BitSet();
+        fo_table_column.or(CommonBorderPaddingBackgroundProperties);
+        fo_table_column.set(Constants.PR_BORDER_AFTER_PRECEDENCE);
+        fo_table_column.set(Constants.PR_BORDER_BEFORE_PRECEDENCE);
+        fo_table_column.set(Constants.PR_BORDER_END_PRECEDENCE);
+        fo_table_column.set(Constants.PR_BORDER_START_PRECEDENCE);
+        fo_table_column.set(Constants.PR_COLUMN_NUMBER);
+        fo_table_column.set(Constants.PR_COLUMN_WIDTH);
+        fo_table_column.set(Constants.PR_NUMBER_COLUMNS_REPEATED);
+        fo_table_column.set(Constants.PR_NUMBER_COLUMNS_SPANNED);
+        fo_table_column.set(Constants.PR_VISIBILITY);
+
+        BitSet fo_table_caption = new BitSet();
+        fo_table_caption.or(CommonAccessibilityProperties);
+        fo_table_caption.or(CommonAuralProperties);
+        fo_table_caption.or(CommonBorderPaddingBackgroundProperties);
+        fo_table_caption.or(CommonRelativePositionProperties);
+        fo_table_caption.set(Constants.PR_BLOCK_PROGRESSION_DIMENSION);
+        fo_table_caption.set(Constants.PR_HEIGHT);
+        fo_table_caption.set(Constants.PR_ID);
+        fo_table_caption.set(Constants.PR_INLINE_PROGRESSION_DIMENSION);
+        fo_table_caption.set(Constants.PR_PAGE_BREAK_INSIDE);
+        fo_table_caption.set(Constants.PR_KEEP_TOGETHER);
+        fo_table_caption.set(Constants.PR_WIDTH);
+
+        BitSet fo_table_header = new BitSet();
+        fo_table_header.or(CommonAccessibilityProperties);
+        fo_table_header.or(CommonAuralProperties);
+        fo_table_header.or(CommonBorderPaddingBackgroundProperties);
+        fo_table_header.or(CommonRelativePositionProperties);
+        fo_table_header.set(Constants.PR_BORDER_AFTER_PRECEDENCE);
+        fo_table_header.set(Constants.PR_BORDER_BEFORE_PRECEDENCE);
+        fo_table_header.set(Constants.PR_BORDER_END_PRECEDENCE);
+        fo_table_header.set(Constants.PR_BORDER_START_PRECEDENCE);
+        fo_table_header.set(Constants.PR_ID);
+        fo_table_header.set(Constants.PR_VISIBILITY);
+
+        BitSet fo_table_footer = new BitSet();
+        fo_table_footer.or(CommonAccessibilityProperties);
+        fo_table_footer.or(CommonAuralProperties);
+        fo_table_footer.or(CommonBorderPaddingBackgroundProperties);
+        fo_table_footer.or(CommonRelativePositionProperties);
+        fo_table_footer.set(Constants.PR_BORDER_AFTER_PRECEDENCE);
+        fo_table_footer.set(Constants.PR_BORDER_BEFORE_PRECEDENCE);
+        fo_table_footer.set(Constants.PR_BORDER_END_PRECEDENCE);
+        fo_table_footer.set(Constants.PR_BORDER_START_PRECEDENCE);
+        fo_table_footer.set(Constants.PR_ID);
+        fo_table_footer.set(Constants.PR_VISIBILITY);
+
+        BitSet fo_table_body = new BitSet();
+        fo_table_body.or(CommonAccessibilityProperties);
+        fo_table_body.or(CommonAuralProperties);
+        fo_table_body.or(CommonBorderPaddingBackgroundProperties);
+        fo_table_body.or(CommonRelativePositionProperties);
+        fo_table_body.set(Constants.PR_BORDER_AFTER_PRECEDENCE);
+        fo_table_body.set(Constants.PR_BORDER_BEFORE_PRECEDENCE);
+        fo_table_body.set(Constants.PR_BORDER_END_PRECEDENCE);
+        fo_table_body.set(Constants.PR_BORDER_START_PRECEDENCE);
+        fo_table_body.set(Constants.PR_ID);
+        fo_table_body.set(Constants.PR_VISIBILITY);
+
+        BitSet fo_table_row = new BitSet();
+        fo_table_row.or(CommonAccessibilityProperties);
+        fo_table_row.set(Constants.PR_BLOCK_PROGRESSION_DIMENSION);
+        fo_table_row.or(CommonAuralProperties);
+        fo_table_row.or(CommonBorderPaddingBackgroundProperties);
+        fo_table_row.or(CommonRelativePositionProperties);
+        fo_table_row.set(Constants.PR_BORDER_AFTER_PRECEDENCE);
+        fo_table_row.set(Constants.PR_BORDER_BEFORE_PRECEDENCE);
+        fo_table_row.set(Constants.PR_BORDER_END_PRECEDENCE);
+        fo_table_row.set(Constants.PR_BORDER_START_PRECEDENCE);
+        fo_table_row.set(Constants.PR_PAGE_BREAK_AFTER);
+        fo_table_row.set(Constants.PR_PAGE_BREAK_BEFORE);
+        fo_table_row.set(Constants.PR_BREAK_AFTER);
+        fo_table_row.set(Constants.PR_BREAK_BEFORE);
+        fo_table_row.set(Constants.PR_ID);
+        fo_table_row.set(Constants.PR_HEIGHT);
+        fo_table_row.set(Constants.PR_PAGE_BREAK_INSIDE);
+        fo_table_row.set(Constants.PR_KEEP_TOGETHER);
+        fo_table_row.set(Constants.PR_KEEP_WITH_NEXT);
+        fo_table_row.set(Constants.PR_KEEP_WITH_PREVIOUS);
+        fo_table_row.set(Constants.PR_VISIBILITY);
+
+        BitSet fo_table_cell = new BitSet();
+        fo_table_cell.or(CommonAccessibilityProperties);
+        fo_table_cell.or(CommonAuralProperties);
+        fo_table_cell.or(CommonBorderPaddingBackgroundProperties);
+        fo_table_cell.or(CommonRelativePositionProperties);
+        fo_table_cell.set(Constants.PR_BORDER_AFTER_PRECEDENCE);
+        fo_table_cell.set(Constants.PR_BORDER_BEFORE_PRECEDENCE);
+        fo_table_cell.set(Constants.PR_BORDER_END_PRECEDENCE);
+        fo_table_cell.set(Constants.PR_BORDER_START_PRECEDENCE);
+        fo_table_cell.set(Constants.PR_BLOCK_PROGRESSION_DIMENSION);
+        fo_table_cell.set(Constants.PR_COLUMN_NUMBER);
+        fo_table_cell.set(Constants.PR_DISPLAY_ALIGN);
+        fo_table_cell.set(Constants.PR_RELATIVE_ALIGN);
+        fo_table_cell.set(Constants.PR_EMPTY_CELLS);
+        fo_table_cell.set(Constants.PR_ENDS_ROW);
+        fo_table_cell.set(Constants.PR_HEIGHT);
+        fo_table_cell.set(Constants.PR_ID);
+        fo_table_cell.set(Constants.PR_INLINE_PROGRESSION_DIMENSION);
+        fo_table_cell.set(Constants.PR_NUMBER_COLUMNS_SPANNED);
+        fo_table_cell.set(Constants.PR_NUMBER_ROWS_SPANNED);
+        fo_table_cell.set(Constants.PR_STARTS_ROW);
+        fo_table_cell.set(Constants.PR_WIDTH);
+
+        BitSet fo_list_block = new BitSet();
+        fo_list_block.or(CommonAccessibilityProperties);
+        fo_list_block.or(CommonAuralProperties);
+        fo_list_block.or(CommonBorderPaddingBackgroundProperties);
+        fo_list_block.or(CommonMarginPropertiesBlock);
+        fo_list_block.or(CommonRelativePositionProperties);
+        fo_list_block.set(Constants.PR_PAGE_BREAK_AFTER);
+        fo_list_block.set(Constants.PR_PAGE_BREAK_BEFORE);
+        fo_list_block.set(Constants.PR_BREAK_AFTER);
+        fo_list_block.set(Constants.PR_BREAK_BEFORE);
+        fo_list_block.set(Constants.PR_ID);
+        fo_list_block.set(Constants.PR_PAGE_BREAK_INSIDE);
+        fo_list_block.set(Constants.PR_KEEP_TOGETHER);
+        fo_list_block.set(Constants.PR_KEEP_WITH_NEXT);
+        fo_list_block.set(Constants.PR_KEEP_WITH_PREVIOUS);
+        fo_list_block.set(Constants.PR_PROVISIONAL_DISTANCE_BETWEEN_STARTS);
+        fo_list_block.set(Constants.PR_PROVISIONAL_LABEL_SEPARATION);
+
+        BitSet fo_list_item = new BitSet();
+        fo_list_item.or(CommonAccessibilityProperties);
+        fo_list_item.or(CommonAuralProperties);
+        fo_list_item.or(CommonBorderPaddingBackgroundProperties);
+        fo_list_item.or(CommonMarginPropertiesBlock);
+        fo_list_item.or(CommonRelativePositionProperties);
+        fo_list_item.set(Constants.PR_PAGE_BREAK_AFTER);
+        fo_list_item.set(Constants.PR_PAGE_BREAK_BEFORE);
+        fo_list_item.set(Constants.PR_BREAK_AFTER);
+        fo_list_item.set(Constants.PR_BREAK_BEFORE);
+        fo_list_item.set(Constants.PR_ID);
+        fo_list_item.set(Constants.PR_PAGE_BREAK_INSIDE);
+        fo_list_item.set(Constants.PR_KEEP_TOGETHER);
+        fo_list_item.set(Constants.PR_KEEP_WITH_NEXT);
+        fo_list_item.set(Constants.PR_KEEP_WITH_PREVIOUS);
+        fo_list_item.set(Constants.PR_RELATIVE_ALIGN);
+
+        BitSet fo_list_item_body = new BitSet();
+        fo_list_item_body.or(CommonAccessibilityProperties);
+        fo_list_item_body.set(Constants.PR_ID);
+        fo_list_item_body.set(Constants.PR_PAGE_BREAK_INSIDE);
+        fo_list_item_body.set(Constants.PR_KEEP_TOGETHER);
+
+        BitSet fo_list_item_label = new BitSet();
+        fo_list_item_label.or(CommonAccessibilityProperties);
+        fo_list_item_label.set(Constants.PR_ID);
+        fo_list_item_label.set(Constants.PR_PAGE_BREAK_INSIDE);
+        fo_list_item_label.set(Constants.PR_KEEP_TOGETHER);
+
+        BitSet fo_basic_link = new BitSet();
+        fo_basic_link.or(CommonAccessibilityProperties);
+        fo_basic_link.or(CommonAuralProperties);
+        fo_basic_link.or(CommonBorderPaddingBackgroundProperties);
+        fo_basic_link.or(CommonMarginPropertiesInline);
+        fo_basic_link.or(CommonRelativePositionProperties);
+        fo_basic_link.set(Constants.PR_VERTICAL_ALIGN);
+        fo_basic_link.set(Constants.PR_ALIGNMENT_ADJUST);
+        fo_basic_link.set(Constants.PR_ALIGNMENT_BASELINE);
+        fo_basic_link.set(Constants.PR_BASELINE_SHIFT);
+        fo_basic_link.set(Constants.PR_DESTINATION_PLACEMENT_OFFSET);
+        fo_basic_link.set(Constants.PR_DOMINANT_BASELINE);
+        fo_basic_link.set(Constants.PR_EXTERNAL_DESTINATION);
+        fo_basic_link.set(Constants.PR_ID);
+        fo_basic_link.set(Constants.PR_INDICATE_DESTINATION);
+        fo_basic_link.set(Constants.PR_INTERNAL_DESTINATION);
+        fo_basic_link.set(Constants.PR_PAGE_BREAK_INSIDE);
+        fo_basic_link.set(Constants.PR_KEEP_TOGETHER);
+        fo_basic_link.set(Constants.PR_KEEP_WITH_NEXT);
+        fo_basic_link.set(Constants.PR_KEEP_WITH_PREVIOUS);
+        fo_basic_link.set(Constants.PR_LINE_HEIGHT);
+        fo_basic_link.set(Constants.PR_SHOW_DESTINATION);
+        fo_basic_link.set(Constants.PR_TARGET_PROCESSING_CONTEXT);
+        fo_basic_link.set(Constants.PR_TARGET_PRESENTATION_CONTEXT);
+        fo_basic_link.set(Constants.PR_TARGET_STYLESHEET);
+
+        BitSet fo_multi_switch = new BitSet();
+        fo_multi_switch.or(CommonAccessibilityProperties);
+        fo_multi_switch.set(Constants.PR_AUTO_RESTORE);
+        fo_multi_switch.set(Constants.PR_ID);
+
+        BitSet fo_multi_case = new BitSet();
+        fo_multi_case.or(CommonAccessibilityProperties);
+        fo_multi_case.set(Constants.PR_ID);
+        fo_multi_case.set(Constants.PR_STARTING_STATE);
+        fo_multi_case.set(Constants.PR_CASE_NAME);
+        fo_multi_case.set(Constants.PR_CASE_TITLE);
+
+        BitSet fo_multi_toggle = new BitSet();
+        fo_multi_toggle.or(CommonAccessibilityProperties);
+        fo_multi_toggle.set(Constants.PR_ID);
+        fo_multi_toggle.set(Constants.PR_SWITCH_TO);
+
+        BitSet fo_multi_properties = new BitSet();
+        fo_multi_properties.or(CommonAccessibilityProperties);
+        fo_multi_properties.set(Constants.PR_ID);
+
+        BitSet fo_multi_property_set = new BitSet();
+        fo_multi_property_set.set(Constants.PR_ID);
+        fo_multi_property_set.set(Constants.PR_ACTIVE_STATE);
+
+        BitSet fo_float = new BitSet();
+        fo_float.set(Constants.PR_FLOAT);
+        fo_float.set(Constants.PR_CLEAR);
+
+        BitSet fo_footnote = new BitSet();
+        fo_footnote.or(CommonAccessibilityProperties);
+
+        BitSet fo_footnote_body = new BitSet();
+        fo_footnote_body.or(CommonAccessibilityProperties);
+
+        BitSet fo_wrapper = new BitSet();
+        fo_wrapper.set(Constants.PR_ID);
+
+        BitSet fo_marker = new BitSet();
+        fo_marker.set(Constants.PR_MARKER_CLASS_NAME);
+
+        BitSet fo_retrieve_marker = new BitSet();
+        fo_retrieve_marker.set(Constants.PR_RETRIEVE_CLASS_NAME);
+        fo_retrieve_marker.set(Constants.PR_RETRIEVE_POSITION);
+        fo_retrieve_marker.set(Constants.PR_RETRIEVE_BOUNDARY);
+
+        boolean loop = true;
+        while (loop) {
+            loop = false;
+
+            loop = mergeContent(fo_root, fo_layout_master_set, loop);
+    
+            loop = mergeContent(fo_root, fo_declaration, loop);
+    
+            loop = mergeContent(fo_root, fo_page_sequence, loop);
+    
+            loop = mergeContent(fo_declaration, fo_color_profile, loop);
+    
+            loop = mergeContent(fo_page_sequence, fo_title, loop);
+    
+            loop = mergeContent(fo_page_sequence, fo_static_content, loop);
+    
+            loop = mergeContent(fo_page_sequence, fo_flow, loop);
+    
+            loop = mergeContent(fo_layout_master_set, fo_simple_page_master, loop);
+    
+            loop = mergeContent(fo_layout_master_set, fo_page_sequence_master, loop);
+    
+            loop = mergeContent(fo_page_sequence_master, fo_single_page_master_reference, loop);
+    
+            loop = mergeContent(fo_page_sequence_master, fo_repeatable_page_master_reference, loop);
+    
+            loop = mergeContent(fo_page_sequence_master, fo_repeatable_page_master_alternatives, loop);
+    
+            loop = mergeContent(fo_repeatable_page_master_alternatives, fo_conditional_page_master_reference, loop);
+    
+            loop = mergeContent(fo_simple_page_master, fo_region_body, loop);
+    
+            loop = mergeContent(fo_simple_page_master, fo_region_before, loop);
+    
+            loop = mergeContent(fo_simple_page_master, fo_region_after, loop);
+    
+            loop = mergeContent(fo_simple_page_master, fo_region_start, loop);
+    
+            loop = mergeContent(fo_simple_page_master, fo_region_end, loop);
+    
+            loop = mergeContent(fo_flow, fo_block, loop);
+            loop = mergeContent(fo_flow, fo_block_container, loop);
+            loop = mergeContent(fo_flow, fo_table_and_caption, loop);
+            loop = mergeContent(fo_flow, fo_table, loop);
+            loop = mergeContent(fo_flow, fo_list_block, loop);
+    
+            loop = mergeContent(fo_static_content, fo_block, loop);
+            loop = mergeContent(fo_static_content, fo_block_container, loop);
+            loop = mergeContent(fo_static_content, fo_table_and_caption, loop);
+            loop = mergeContent(fo_static_content, fo_table, loop);
+            loop = mergeContent(fo_static_content, fo_list_block, loop);
+    
+            loop = mergeContent(fo_title, fo_bidi_override, loop);
+            loop = mergeContent(fo_title, fo_character, loop);
+            loop = mergeContent(fo_title, fo_external_graphic, loop);
+            loop = mergeContent(fo_title, fo_instream_foreign_object, loop);
+            loop = mergeContent(fo_title, fo_inline, loop);
+            loop = mergeContent(fo_title, fo_inline_container, loop);
+            loop = mergeContent(fo_title, fo_leader, loop);
+            loop = mergeContent(fo_title, fo_page_number, loop);
+            loop = mergeContent(fo_title, fo_page_number_citation, loop);
+            loop = mergeContent(fo_title, fo_basic_link, loop);
+            loop = mergeContent(fo_title, fo_multi_toggle, loop);
+    
+            loop = mergeContent(fo_block, fo_bidi_override, loop);
+            loop = mergeContent(fo_block, fo_character, loop);
+            loop = mergeContent(fo_block, fo_external_graphic, loop);
+            loop = mergeContent(fo_block, fo_instream_foreign_object, loop);
+            loop = mergeContent(fo_block, fo_inline, loop);
+            loop = mergeContent(fo_block, fo_inline_container, loop);
+            loop = mergeContent(fo_block, fo_leader, loop);
+            loop = mergeContent(fo_block, fo_page_number, loop);
+            loop = mergeContent(fo_block, fo_page_number_citation, loop);
+            loop = mergeContent(fo_block, fo_basic_link, loop);
+            loop = mergeContent(fo_block, fo_multi_toggle, loop);
+    
+            loop = mergeContent(fo_block, fo_block, loop);
+            loop = mergeContent(fo_block, fo_block_container, loop);
+            loop = mergeContent(fo_block, fo_table_and_caption, loop);
+            loop = mergeContent(fo_block, fo_table, loop);
+            loop = mergeContent(fo_block, fo_list_block, loop);
+    
+            loop = mergeContent(fo_block_container, fo_block, loop);
+            loop = mergeContent(fo_block_container, fo_block_container, loop);
+            loop = mergeContent(fo_block_container, fo_table_and_caption, loop);
+            loop = mergeContent(fo_block_container, fo_table, loop);
+            loop = mergeContent(fo_block_container, fo_list_block, loop);
+    
+            loop = mergeContent(fo_bidi_override, fo_bidi_override, loop);
+            loop = mergeContent(fo_bidi_override, fo_character, loop);
+            loop = mergeContent(fo_bidi_override, fo_external_graphic, loop);
+            loop = mergeContent(fo_bidi_override, fo_instream_foreign_object, loop);
+            loop = mergeContent(fo_bidi_override, fo_inline, loop);
+            loop = mergeContent(fo_bidi_override, fo_inline_container, loop);
+            loop = mergeContent(fo_bidi_override, fo_leader, loop);
+            loop = mergeContent(fo_bidi_override, fo_page_number, loop);
+            loop = mergeContent(fo_bidi_override, fo_page_number_citation, loop);
+            loop = mergeContent(fo_bidi_override, fo_basic_link, loop);
+            loop = mergeContent(fo_bidi_override, fo_multi_toggle, loop);
+    
+            loop = mergeContent(fo_bidi_override, fo_block, loop);
+            loop = mergeContent(fo_bidi_override, fo_block_container, loop);
+            loop = mergeContent(fo_bidi_override, fo_table_and_caption, loop);
+            loop = mergeContent(fo_bidi_override, fo_table, loop);
+            loop = mergeContent(fo_bidi_override, fo_list_block, loop);
+    
+            loop = mergeContent(fo_inline, fo_bidi_override, loop);
+            loop = mergeContent(fo_inline, fo_character, loop);
+            loop = mergeContent(fo_inline, fo_external_graphic, loop);
+            loop = mergeContent(fo_inline, fo_instream_foreign_object, loop);
+            loop = mergeContent(fo_inline, fo_inline, loop);
+            loop = mergeContent(fo_inline, fo_inline_container, loop);
+            loop = mergeContent(fo_inline, fo_leader, loop);
+            loop = mergeContent(fo_inline, fo_page_number, loop);
+            loop = mergeContent(fo_inline, fo_page_number_citation, loop);
+            loop = mergeContent(fo_inline, fo_basic_link, loop);
+            loop = mergeContent(fo_inline, fo_multi_toggle, loop);
+    
+            loop = mergeContent(fo_inline, fo_block, loop);
+            loop = mergeContent(fo_inline, fo_block_container, loop);
+            loop = mergeContent(fo_inline, fo_table_and_caption, loop);
+            loop = mergeContent(fo_inline, fo_table, loop);
+            loop = mergeContent(fo_inline, fo_list_block, loop);
+    
+            loop = mergeContent(fo_inline_container, fo_block, loop);
+            loop = mergeContent(fo_inline_container, fo_block_container, loop);
+            loop = mergeContent(fo_inline_container, fo_table_and_caption, loop);
+            loop = mergeContent(fo_inline_container, fo_table, loop);
+            loop = mergeContent(fo_inline_container, fo_list_block, loop);
+    
+            loop = mergeContent(fo_leader, fo_bidi_override, loop);
+            loop = mergeContent(fo_leader, fo_character, loop);
+            loop = mergeContent(fo_leader, fo_external_graphic, loop);
+            loop = mergeContent(fo_leader, fo_instream_foreign_object, loop);
+            loop = mergeContent(fo_leader, fo_inline, loop);
+            loop = mergeContent(fo_leader, fo_inline_container, loop);
+            loop = mergeContent(fo_leader, fo_leader, loop);
+            loop = mergeContent(fo_leader, fo_page_number, loop);
+            loop = mergeContent(fo_leader, fo_page_number_citation, loop);
+            loop = mergeContent(fo_leader, fo_basic_link, loop);
+            loop = mergeContent(fo_leader, fo_multi_toggle, loop);
+    
+            loop = mergeContent(fo_table_and_caption, fo_table_caption, loop);
+    
+            loop = mergeContent(fo_table_and_caption, fo_table, loop);
+    
+            loop = mergeContent(fo_table, fo_table_column, loop);
+    
+            loop = mergeContent(fo_table, fo_table_header, loop);
+    
+            loop = mergeContent(fo_table, fo_table_footer, loop);
+    
+            loop = mergeContent(fo_table, fo_table_body, loop);
+    
+            loop = mergeContent(fo_table_caption, fo_block, loop);
+            loop = mergeContent(fo_table_caption, fo_block_container, loop);
+            loop = mergeContent(fo_table_caption, fo_table_and_caption, loop);
+            loop = mergeContent(fo_table_caption, fo_table, loop);
+            loop = mergeContent(fo_table_caption, fo_list_block, loop);
+    
+            loop = mergeContent(fo_table_header, fo_table_row, loop);
+    
+            loop = mergeContent(fo_table_header, fo_table_cell, loop);
+    
+            loop = mergeContent(fo_table_footer, fo_table_row, loop);
+    
+            loop = mergeContent(fo_table_footer, fo_table_cell, loop);
+    
+            loop = mergeContent(fo_table_body, fo_table_row, loop);
+    
+            loop = mergeContent(fo_table_body, fo_table_cell, loop);
+    
+            loop = mergeContent(fo_table_row, fo_table_cell, loop);
+    
+            loop = mergeContent(fo_table_cell, fo_block, loop);
+            loop = mergeContent(fo_table_cell, fo_block_container, loop);
+            loop = mergeContent(fo_table_cell, fo_table_and_caption, loop);
+            loop = mergeContent(fo_table_cell, fo_table, loop);
+            loop = mergeContent(fo_table_cell, fo_list_block, loop);
+    
+            loop = mergeContent(fo_list_block, fo_list_item, loop);
+    
+            loop = mergeContent(fo_list_item, fo_list_item_label, loop);
+    
+            loop = mergeContent(fo_list_item, fo_list_item_body, loop);
+    
+            loop = mergeContent(fo_list_item_body, fo_block, loop);
+            loop = mergeContent(fo_list_item_body, fo_block_container, loop);
+            loop = mergeContent(fo_list_item_body, fo_table_and_caption, loop);
+            loop = mergeContent(fo_list_item_body, fo_table, loop);
+            loop = mergeContent(fo_list_item_body, fo_list_block, loop);
+    
+            loop = mergeContent(fo_list_item_label, fo_block, loop);
+            loop = mergeContent(fo_list_item_label, fo_block_container, loop);
+            loop = mergeContent(fo_list_item_label, fo_table_and_caption, loop);
+            loop = mergeContent(fo_list_item_label, fo_table, loop);
+            loop = mergeContent(fo_list_item_label, fo_list_block, loop);
+    
+            loop = mergeContent(fo_basic_link, fo_bidi_override, loop);
+            loop = mergeContent(fo_basic_link, fo_character, loop);
+            loop = mergeContent(fo_basic_link, fo_external_graphic, loop);
+            loop = mergeContent(fo_basic_link, fo_instream_foreign_object, loop);
+            loop = mergeContent(fo_basic_link, fo_inline, loop);
+            loop = mergeContent(fo_basic_link, fo_inline_container, loop);
+            loop = mergeContent(fo_basic_link, fo_leader, loop);
+            loop = mergeContent(fo_basic_link, fo_page_number, loop);
+            loop = mergeContent(fo_basic_link, fo_page_number_citation, loop);
+            loop = mergeContent(fo_basic_link, fo_basic_link, loop);
+            loop = mergeContent(fo_basic_link, fo_multi_toggle, loop);
+    
+            loop = mergeContent(fo_basic_link, fo_block, loop);
+            loop = mergeContent(fo_basic_link, fo_block_container, loop);
+            loop = mergeContent(fo_basic_link, fo_table_and_caption, loop);
+            loop = mergeContent(fo_basic_link, fo_table, loop);
+            loop = mergeContent(fo_basic_link, fo_list_block, loop);
+    
+            loop = mergeContent(fo_multi_switch, fo_multi_case, loop);
+    
+            loop = mergeContent(fo_multi_case, fo_bidi_override, loop);
+            loop = mergeContent(fo_multi_case, fo_character, loop);
+            loop = mergeContent(fo_multi_case, fo_external_graphic, loop);
+            loop = mergeContent(fo_multi_case, fo_instream_foreign_object, loop);
+            loop = mergeContent(fo_multi_case, fo_inline, loop);
+            loop = mergeContent(fo_multi_case, fo_inline_container, loop);
+            loop = mergeContent(fo_multi_case, fo_leader, loop);
+            loop = mergeContent(fo_multi_case, fo_page_number, loop);
+            loop = mergeContent(fo_multi_case, fo_page_number_citation, loop);
+            loop = mergeContent(fo_multi_case, fo_basic_link, loop);
+            loop = mergeContent(fo_multi_case, fo_multi_toggle, loop);
+    
+            loop = mergeContent(fo_multi_case, fo_block, loop);
+            loop = mergeContent(fo_multi_case, fo_block_container, loop);
+            loop = mergeContent(fo_multi_case, fo_table_and_caption, loop);
+            loop = mergeContent(fo_multi_case, fo_table, loop);
+            loop = mergeContent(fo_multi_case, fo_list_block, loop);
+    
+            loop = mergeContent(fo_multi_toggle, fo_bidi_override, loop);
+            loop = mergeContent(fo_multi_toggle, fo_character, loop);
+            loop = mergeContent(fo_multi_toggle, fo_external_graphic, loop);
+            loop = mergeContent(fo_multi_toggle, fo_instream_foreign_object, loop);
+            loop = mergeContent(fo_multi_toggle, fo_inline, loop);
+            loop = mergeContent(fo_multi_toggle, fo_inline_container, loop);
+            loop = mergeContent(fo_multi_toggle, fo_leader, loop);
+            loop = mergeContent(fo_multi_toggle, fo_page_number, loop);
+            loop = mergeContent(fo_multi_toggle, fo_page_number_citation, loop);
+            loop = mergeContent(fo_multi_toggle, fo_basic_link, loop);
+            loop = mergeContent(fo_multi_toggle, fo_multi_toggle, loop);
+    
+            loop = mergeContent(fo_multi_toggle, fo_block, loop);
+            loop = mergeContent(fo_multi_toggle, fo_block_container, loop);
+            loop = mergeContent(fo_multi_toggle, fo_table_and_caption, loop);
+            loop = mergeContent(fo_multi_toggle, fo_table, loop);
+            loop = mergeContent(fo_multi_toggle, fo_list_block, loop);
+    
+            loop = mergeContent(fo_multi_properties, fo_multi_property_set, loop);
+    
+            loop = mergeContent(fo_multi_properties, fo_wrapper, loop);
+    
+            loop = mergeContent(fo_float, fo_block, loop);
+            loop = mergeContent(fo_float, fo_block_container, loop);
+            loop = mergeContent(fo_float, fo_table_and_caption, loop);
+            loop = mergeContent(fo_float, fo_table, loop);
+            loop = mergeContent(fo_float, fo_list_block, loop);
+    
+            loop = mergeContent(fo_footnote, fo_inline, loop);
+    
+            loop = mergeContent(fo_footnote, fo_footnote_body, loop);
+    
+            loop = mergeContent(fo_footnote_body, fo_block, loop);
+            loop = mergeContent(fo_footnote_body, fo_block_container, loop);
+            loop = mergeContent(fo_footnote_body, fo_table_and_caption, loop);
+            loop = mergeContent(fo_footnote_body, fo_table, loop);
+            loop = mergeContent(fo_footnote_body, fo_list_block, loop);
+    
+            loop = mergeContent(fo_wrapper, fo_bidi_override, loop);
+            loop = mergeContent(fo_wrapper, fo_character, loop);
+            loop = mergeContent(fo_wrapper, fo_external_graphic, loop);
+            loop = mergeContent(fo_wrapper, fo_instream_foreign_object, loop);
+            loop = mergeContent(fo_wrapper, fo_inline, loop);
+            loop = mergeContent(fo_wrapper, fo_inline_container, loop);
+            loop = mergeContent(fo_wrapper, fo_leader, loop);
+            loop = mergeContent(fo_wrapper, fo_page_number, loop);
+            loop = mergeContent(fo_wrapper, fo_page_number_citation, loop);
+            loop = mergeContent(fo_wrapper, fo_basic_link, loop);
+            loop = mergeContent(fo_wrapper, fo_multi_toggle, loop);
+    
+            loop = mergeContent(fo_wrapper, fo_block, loop);
+            loop = mergeContent(fo_wrapper, fo_block_container, loop);
+            loop = mergeContent(fo_wrapper, fo_table_and_caption, loop);
+            loop = mergeContent(fo_wrapper, fo_table, loop);
+            loop = mergeContent(fo_wrapper, fo_list_block, loop);
+    
+            loop = mergeContent(fo_marker, fo_bidi_override, loop);
+            loop = mergeContent(fo_marker, fo_character, loop);
+            loop = mergeContent(fo_marker, fo_external_graphic, loop);
+            loop = mergeContent(fo_marker, fo_instream_foreign_object, loop);
+            loop = mergeContent(fo_marker, fo_inline, loop);
+            loop = mergeContent(fo_marker, fo_inline_container, loop);
+            loop = mergeContent(fo_marker, fo_leader, loop);
+            loop = mergeContent(fo_marker, fo_page_number, loop);
+            loop = mergeContent(fo_marker, fo_page_number_citation, loop);
+            loop = mergeContent(fo_marker, fo_basic_link, loop);
+            loop = mergeContent(fo_marker, fo_multi_toggle, loop);
+    
+            loop = mergeContent(fo_marker, fo_block, loop);
+            loop = mergeContent(fo_marker, fo_block_container, loop);
+            loop = mergeContent(fo_marker, fo_table_and_caption, loop);
+            loop = mergeContent(fo_marker, fo_table, loop);
+            loop = mergeContent(fo_marker, fo_list_block, loop);
+    
+       }
+        mapping[Constants.FO_ROOT] = makeSparseIndices(fo_root);
+        mapping[Constants.FO_DECLARATION] = makeSparseIndices(fo_declaration);
+        mapping[Constants.FO_COLOR_PROFILE] = makeSparseIndices(fo_color_profile);
+        mapping[Constants.FO_PAGE_SEQUENCE] = makeSparseIndices(fo_page_sequence);
+        mapping[Constants.FO_LAYOUT_MASTER_SET] = makeSparseIndices(fo_layout_master_set);
+        mapping[Constants.FO_PAGE_SEQUENCE_MASTER] = makeSparseIndices(fo_page_sequence_master);
+        mapping[Constants.FO_SINGLE_PAGE_MASTER_REFERENCE] = makeSparseIndices(fo_single_page_master_reference);
+        mapping[Constants.FO_REPEATABLE_PAGE_MASTER_REFERENCE] = makeSparseIndices(fo_repeatable_page_master_reference);
+        mapping[Constants.FO_REPEATABLE_PAGE_MASTER_ALTERNATIVES] = makeSparseIndices(fo_repeatable_page_master_alternatives);
+        mapping[Constants.FO_CONDITIONAL_PAGE_MASTER_REFERENCE] = makeSparseIndices(fo_conditional_page_master_reference);
+        mapping[Constants.FO_SIMPLE_PAGE_MASTER] = makeSparseIndices(fo_simple_page_master);
+        mapping[Constants.FO_REGION_BODY] = makeSparseIndices(fo_region_body);
+        mapping[Constants.FO_REGION_BEFORE] = makeSparseIndices(fo_region_before);
+        mapping[Constants.FO_REGION_AFTER] = makeSparseIndices(fo_region_after);
+        mapping[Constants.FO_REGION_START] = makeSparseIndices(fo_region_start);
+        mapping[Constants.FO_REGION_END] = makeSparseIndices(fo_region_end);
+        mapping[Constants.FO_FLOW] = makeSparseIndices(fo_flow);
+        mapping[Constants.FO_STATIC_CONTENT] = makeSparseIndices(fo_static_content);
+        mapping[Constants.FO_TITLE] = makeSparseIndices(fo_title);
+        mapping[Constants.FO_BLOCK] = makeSparseIndices(fo_block);
+        mapping[Constants.FO_BLOCK_CONTAINER] = makeSparseIndices(fo_block_container);
+        mapping[Constants.FO_BIDI_OVERRIDE] = makeSparseIndices(fo_bidi_override);
+        mapping[Constants.FO_CHARACTER] = makeSparseIndices(fo_character);
+        mapping[Constants.FO_INITIAL_PROPERTY_SET] = makeSparseIndices(fo_initial_property_set);
+        mapping[Constants.FO_EXTERNAL_GRAPHIC] = makeSparseIndices(fo_external_graphic);
+        mapping[Constants.FO_INSTREAM_FOREIGN_OBJECT] = makeSparseIndices(fo_instream_foreign_object);
+        mapping[Constants.FO_INLINE] = makeSparseIndices(fo_inline);
+        mapping[Constants.FO_INLINE_CONTAINER] = makeSparseIndices(fo_inline_container);
+        mapping[Constants.FO_LEADER] = makeSparseIndices(fo_leader);
+        mapping[Constants.FO_PAGE_NUMBER] = makeSparseIndices(fo_page_number);
+        mapping[Constants.FO_PAGE_NUMBER_CITATION] = makeSparseIndices(fo_page_number_citation);
+        mapping[Constants.FO_TABLE_AND_CAPTION] = makeSparseIndices(fo_table_and_caption);
+        mapping[Constants.FO_TABLE] = makeSparseIndices(fo_table);
+        mapping[Constants.FO_TABLE_COLUMN] = makeSparseIndices(fo_table_column);
+        mapping[Constants.FO_TABLE_CAPTION] = makeSparseIndices(fo_table_caption);
+        mapping[Constants.FO_TABLE_HEADER] = makeSparseIndices(fo_table_header);
+        mapping[Constants.FO_TABLE_FOOTER] = makeSparseIndices(fo_table_footer);
+        mapping[Constants.FO_TABLE_BODY] = makeSparseIndices(fo_table_body);
+        mapping[Constants.FO_TABLE_ROW] = makeSparseIndices(fo_table_row);
+        mapping[Constants.FO_TABLE_CELL] = makeSparseIndices(fo_table_cell);
+        mapping[Constants.FO_LIST_BLOCK] = makeSparseIndices(fo_list_block);
+        mapping[Constants.FO_LIST_ITEM] = makeSparseIndices(fo_list_item);
+        mapping[Constants.FO_LIST_ITEM_BODY] = makeSparseIndices(fo_list_item_body);
+        mapping[Constants.FO_LIST_ITEM_LABEL] = makeSparseIndices(fo_list_item_label);
+        mapping[Constants.FO_BASIC_LINK] = makeSparseIndices(fo_basic_link);
+        mapping[Constants.FO_MULTI_SWITCH] = makeSparseIndices(fo_multi_switch);
+        mapping[Constants.FO_MULTI_CASE] = makeSparseIndices(fo_multi_case);
+        mapping[Constants.FO_MULTI_TOGGLE] = makeSparseIndices(fo_multi_toggle);
+        mapping[Constants.FO_MULTI_PROPERTIES] = makeSparseIndices(fo_multi_properties);
+        mapping[Constants.FO_MULTI_PROPERTY_SET] = makeSparseIndices(fo_multi_property_set);
+        mapping[Constants.FO_FLOAT] = makeSparseIndices(fo_float);
+        mapping[Constants.FO_FOOTNOTE] = makeSparseIndices(fo_footnote);
+        mapping[Constants.FO_FOOTNOTE_BODY] = makeSparseIndices(fo_footnote_body);
+        mapping[Constants.FO_WRAPPER] = makeSparseIndices(fo_wrapper);
+        mapping[Constants.FO_MARKER] = makeSparseIndices(fo_marker);
+        mapping[Constants.FO_RETRIEVE_MARKER] = makeSparseIndices(fo_retrieve_marker);
+
+    }
+
+    private static short[] makeSparseIndices(BitSet set) {
+        short[] indices = new short[Constants.PROPERTY_COUNT];
+        indices[0] = (short) (set.cardinality() + 1);
+        int j = 1;
+        for (int i = set.nextSetBit(0); i >= 0; i = set.nextSetBit(i+1)) {
+            indices[i] = (short) j++;
+        }
+        return indices;
+    }
+
+    private static boolean mergeContent(BitSet node, BitSet content,
+                                         boolean loop)
+    {
+        int c = node.cardinality();
+        node.or(content);
+        if (c == node.cardinality())
+            return loop;
+        return true;
+    }
+
+    public static short[] getPropertySet(int elementId) {
+        if (mapping == null)
+            initialize();
+        return mapping[elementId];
+    }
+}