// any values in that range. To see why, consider the case where:
    // safeMin <= {hi,lo} <= safeMax
    // where {hi,lo} are characters forming a surrogate pair such that:
    // codePointOf(hi, lo) > safeMax
    // which would result in the surrogate pair being (wrongly) considered safe.
    // If we clip the safe range used during the per-character tests so it is

 *   <li>comparing each object against null returns false
 *   <li>comparing each object against an instance of an incompatible class returns false
 *   <li>comparing each pair of objects within the same equality group returns true
 *   <li>comparing each pair of objects from different equality groups returns false
 *   <li>the hash codes of any two equal objects are equal
 * </ul>
 *

   * column key {@code c}, the returned table contains a mapping with row key {@code r} and column
   * key {@code c}. If that row key / column key pair in not in {@code table}, the pair maps to
   * {@code null} in the generated table.
   *
   * <p>The returned table allows subsequent {@code put} calls with the row keys in {@code

   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing
   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
   */
  @SuppressWarnings({
    // We use this method only for cases in which we need to decompose to primitives.
    "GoodTime-ApiWithNumericTimeUnit",
    "GoodTime-DecomposeToPrimitive",

          <defaultValue></defaultValue>
          <identifier>true</identifier>
        </field>
        <field>
          <name>extension</name>
          <version>1.1.0+</version>
          <type>String</type>
          <description>The file extension of the sub-artifact. Each classifier and extension pair may only appear once.</description>

KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-->

<project>
  <modelVersion>4.0.0</modelVersion>
  <artifactId>aid</artifactId>
  <groupId>gid</groupId>
  <version>0.1</version>
  <packaging>pom</packaging>

  <build>
    <pluginManagement>
      <plugins>
        <plugin>
          <groupId>build</groupId>

        bufferIndex += 4;

        int pad = bufferIndex - ( getHeaderStart() + securityBufferOffset );
        this.blob = new byte[securityBufferLength];
        System.arraycopy(buffer, getHeaderStart() + securityBufferOffset, this.blob, 0, securityBufferLength);
        bufferIndex += pad;
        bufferIndex += securityBufferLength;

        return bufferIndex - start;
    }

  public void testPutStringWithLowSurrogate() {
    // we pad because the dummy hash function we use to test this, merely copies the input into
    // the output, so the input must be at least 32 bits, since the output has to be that long
    assertPutString(new char[] {'p', HashTestUtils.randomLowSurrogate(new Random())});
  }

  public void testPutStringWithHighSurrogate() {

//      output tensor naming, but it the index is actually an input index)
struct EdgeSpec : public std::pair<string, string> {
  typedef std::pair<string, string> Base;

  // Inherit the set of constructors
  using Base::pair;

  string ToString() const { return strings::StrCat(first, "->", second); }
};

class CApiFunctionTest : public ::testing::Test {
 protected:

            throw new CIFSException("Missing AvEOL");
        }
        return pairs;
    }


    /**
     * 
     * @param pairs
     * @param type
     * @return whether the list contains a pair of that type
     */
    public static boolean contains ( List<AvPair> pairs, int type ) {
        if ( pairs == null ) {
            return false;
        }
        for ( AvPair p : pairs ) {